“Everyone has a plan until they get punched in the face.”
Every idea is also perfect until it gets written down.
Often enough, seemingly cohesive thoughts in our minds fall apart when put to paper. We see places where our thinking was muddled, unresolved, or incomplete. The magic of writing is that it forces us to confront and endure the friction required to refine a thought into an idea.
Then came AI.
Early LLMs required a lot of babysitting to perform any real task. The models were likely to misunderstand and steer into an unintended direction. To solve that, we would jam tons of data into the context window and pray that the model would somehow create the perfect output. When the inevitably disappointing result comes back, we would add on a couple of extra restrictions, run it again, and keep looping until the model is forced onto the correct path. In the process, we gradually gained clarity about our end goals and documented the different steps in solving our problem.
It wasn’t the same as writing an essay from the kernel of an idea, but it was close enough.
Then came Opus 4.5 and other models that broke through to the next level of capability. For the first time, AI could, broadly, handle things and be competitive with human reliability. It could be left to its own devices and, more often than not, create useful output.
With a simple prompt, these models can write scripts or entire programs. They can generate websites from scratch, integrating third-party tools as needed to better deliver on user intent.
And as single-turn models became multi-turn agents, user ideas could stay muddy for far longer than before. Agents could reason through ambiguity in the initial idea and make design choices to continue their progress. This, in turn, means that we can assemble a complete output without ever fully understanding our original idea.
But when the amount of work needed to realize an idea goes down, the starting quality of these ideas also decreases. And what does the future of working with agents look like if our initial ideas are becoming less clear?
Determinism
Before we can answer that, we first need to talk about determinism.
A deterministic system is one that produces the same outputs when provided with identical inputs and starting conditions. Calculators are deterministic. Given the same “2+2” input a thousand times, they will output “4” a thousand times. The value of these systems is in their predictability.
Large language models were not built to be deterministic engines. Their reasoning comes from the ability to approximate human reasoning by guessing the most statistically likely next word, which is, if anything, a non-deterministic process. As model intelligence has increased, we’ve also fine-tuned the model towards consistent output.
This gets the models to a place where we can depend on them to do meaningful units of work, but the knife cuts both ways. If our initial ideas are undercooked, then the deterministic models will hit a wall and mirror back with a half-baked output.
Paradoxically, as the quality of our ideas decreases, we also want the models to also be less deterministic. Knowing exactly what we want and handing the project over to an agent that delivers in a consistent, predictable way can actually limit the potential of AI-generated work.
The mathematical term for this is hill climbing.
Imagine a blindfolded climber trying to reach the highest peak in a mountain range. The most predictable strategy is to feel the ground and always step upward. By strictly following this rule, the climber will eventually reach a summit. However, that summit might just be a small foothill. Under this strategy, the climber scales the closest hill instead of the highest one.
This mirrors how a deterministic AI handles an underdeveloped prompt. It will go down likely-seeming paths with too much confidence and too little consideration of other paths.
Sufficient determinism avoids bad outcomes but might also opt to pass up more experimental paths that could result in even better outcomes. In many cases, determinism trades potential to buy safety, and the amount of agent ability potentially left on the table for the sake of caution increases with every new frontier model.
When starting ideas are weak, the model needs permission to wander.
In the past, prototyping was expensive. There was no alternative to actually rolling up one’s sleeves and putting in the work. John Doerr once said, “Ideas are cheap, execution is everything,” but as each new model family drives down the cost of execution, even half-baked ideas can bear fruit.
In the world of cheap execution, we can start deliberately injecting ambiguity into our prompts to cast a wider net, granting the AI the necessary slack to explore the broader problem space before presenting us with options. Or we could ask a swarm of agents to take our unrefined thought and execute it simultaneously from drastically different perspectives, such as engineer, product manager, or even CEO.
Future work will start with us throwing our thoughts into a swarm of agents and counting on the non-determinism of the AI to act as a prism, scattering a single idea into a spectrum of fully realized possibilities.
Agents of Work
Today, we are leveraging AI models and agents to build a gallery of finished products. We then pick, choose, discard, and combine from the different outputs. This process relies heavily on a personal understanding of the difference between good and bad from the AI outputs.
But this curation process doesn’t always unearth a masterpiece. Because non-deterministic models are allowed to wander, we will inevitably encounter situations where the AI simply executed the idea poorly. The model's various iterations might entirely miss the soul of the prompt, leaving us sifting through a dozen perfectly articulate misses.
This is yet another hill climbing problem. Do we spin up more agents and count on the model’s non-determinism? Or do we change the prompt to tackle the problem from a different angle? Or, worse, what if the idea was actually flawed?
None of these questions can be answered by an AI model today and is the starting point for why AI hasn’t made a large impact in enterprises outside a couple of limited areas.
When a human undertakes a large, complex problem such as selling into a new account or building a new feature, they are embarking on a long decision tree. That tree branches with every new action and external piece of information. While an AI agent could eventually take the right path, in practice, they need lots of hand-holding. Long, non-plagiarized human projects are always substantially unique compared to other human efforts.
Every company has their own internal decision tree in the form of their policies, relationships, and culture.
For us, learning this tree is largely a matter of osmosis. We learn the ropes through onboarding documents, Slack channel histories, and input from coworkers. Over time, we figure out who holds the institutional knowledge for a legacy system or which specific stakeholder needs to sign off on a design change.
Unfortunately, we cannot rely on the model's generalized, pre-trained knowledge to navigate the highly specific decision tree of a single company. To have AI agents perform real units of work, we need to document our expert experience and evaluations.
Instead of refining a single idea on a blank page, we now have to refine the systems and logic of our entire organization. We have to take that implicit “osmosis” and turn it into explicit data. This looks different for every function. For sales, it might be breaking down the intuition of a top-tier sales rep and creating datasets around their talk tracks, patterns, and playbooks. For product, it would be around ingesting past PRDs, conducting user interviews, and understanding how the best PMs drive alignment across the organization.
AI agents need this expert experience and evaluations decision tree for more “good path” branchings in their decision-making. Each branch might not make much of a difference by itself, but the accumulation of hundreds or thousands of those choices allows an agent to complete real units of work.
The bottleneck for the AI agentic future isn't model capability or the starting quality of our ideas. It’s the clarity of the environment we ask these models to operate in. The biggest gains from AI won’t come from deploying the largest swarm of agents or spending the most on tokens.
The agentic future belongs to the organizations that have conquered the friction of understanding and writing down their business decision tree.