Recently, I spotted something interesting: Evolution in action.

Different corners of agentic LLM engineering began to find similar working solutions to their specific problem spaces. Even though these disciplines experience different evolutionary pressures, they converge at similar solutions.

There is a reason why penguins look similar to seals (hydrodynamic hunters that waddle on land), and why life has a tendency to turn into crabs. The solution space was constrained enough that multiple searches found the same peak.

In biology, this is called convergent evolution. In software architecture, this is called a convergent design pattern. These structures appear because constraints force convergence. When enough constraints are imposed on a complex system, the range of viable solutions shrinks towards a narrow region. Multiple independent searches will discover the same peaks.

This is one of these peaks.

Their 2 Cents

The team at Agent Swarm published something insightful. They instrumented a health scan across all their running automations and benchmarked it. The same task, done naively by an LLM agent making sequential tool calls, touched 26 separate API calls and pushed roughly 815,000 tokens through the model's context. Their script accomplished the same in one call, 13 seconds, and ~6,500 tokens. Cost: $0.02 versus a $2.44 floor - a 99.2% reduction per invocation. Great! The billing number was too high, they fixed it.

What they built was a hard boundary between where code executes and what the model sees. Intermediate results stay in the execution environment and the model only sees the return value. They were not the first to draw that line, but nevertheless arrived there.

Not Just Them

In September 2025, Cloudflare shipped Code Mode. Their motivation was performance. Instead of describing every operation as a separate tool, they let the model write code against a typed SDK and execute it safely in a sandboxed runtime. In a February 2026 follow-up they applied the pattern to their own MCP server, collapsing 2,500+ API endpoints from 1.17 million tokens to roughly 1,000.

Anthropic independently explored the same pattern and published their findings in November 2025. A workflow previously consuming 150,000 tokens reimplemented with code execution used 2,000. A 98.7% reduction.

LangChain, the framework most agent developers grew up on, had been moving the same direction for different reasons entirely. Their original AgentExecutor was too rigid to debug, retry, and scale in production. Silent failures, lack of branching, and no durable state. In October 2025, LangChain and LangGraph reached simultaneous GA and AgentExecutor was sunset, with an explicit division of labor: LangChain handles model integrations, LangGraph handles execution. The recommended production path is now a graph where planning and execution are decoupled nodes.

Four independent teams and problem spaces, their motivations being cost, performance, token efficiency and framework maturity.

The Boundary

All three arrived at the same workflow. The model writes a plan or a script, which executes in a sandbox. Intermediate results stay in the sandbox. The model sees only the return value.

This is the boundary: execution environment on one side, model context on the other. Data crosses it exactly once, in one direction, distilled. The boundary was identified much earlier. In April 2023, Simon Willison described the Dual LLM pattern. A privileged model that plans and issues instructions, and a quarantined model that executes against untrusted input and never touches the privileged context. The quarantined executor returns only a result. Willison's motivation was protection against prompt injection, not cost or performance. Same boundary but different pressure. Two years later, Google DeepMind formalized this concept further. Their CaMeL paper built on Willison's architecture, adding explicit control and data flow tracking to make the isolation provably secure. Willison noted at the time that CaMeL might be named for having two humps - an improved evolution of the dual LLM proposal.

Mario Zechner arrived at the same boundary from model quality. Building pi, the minimal coding agent, he measured that MCP servers flooding context with verbose tool catalogs and intermediate output degraded agent recall and task performance, independently of cost. His conclusion was the same: keep raw data out of context, keep the model as lean as possible, giving it only what it needs to act. The boundary as a quality constraint, not a billing one. That's what makes it worth paying attention to.

Four Pressures

The boundary keeps getting rediscovered because the pressures that lead to it are unrelated to each other.

Cost. Agent Swarm's 26 tool calls pushed 815,000 tokens through the model. Their script pushed 6,500. The boundary is a billing optimization that happens to be an architectural one.

Model performance. Zechner quantified this: verbose tool catalogs and intermediate results flooding context degrade agent recall and task quality, independent of cost. The model becomes less capable the more you pollute its context. The boundary is a quality constraint. Keep as much of the raw data out as possible, the model will perform better on what remains.

Non-determinism. The model is the stochastic component clashing with predictable systems, scripted execution inside the sandbox is deterministic. Same inputs, same outputs, unless somebody trips over the cord. Reliability improves when you shrink the surface area where variance can enter. This architectural boundary does that. Everything inside the execution environment is code, only the model handoff introduces randomness but is contained.

Prompt injection. Data that never enters context cannot be adversarial to the model output. Willison's quarantined LLM processes untrusted input in isolation, the privileged planner never sees the raw content, only the sanitized result. Here, the boundary is a security primitive that falls out of the architecture for free, if done right.

The Wrinkle

Convergent evolution requires truly independent lineages. But most engineers building agents passed through LangChain, and their problem-solving instincts were shaped by its architecture. What looks like independent discovery may be more like a branching tree: a common ancestor, different environments, different adaptations.

This changes the story slightly but not fundamentally. The boundary was not discovered independently by teams with no shared priors but was identified early, in a framework many people used, and then repeatedly validated under different pressures. Engineers who learn to read that signal early stop chasing the framework that implements the pattern and start reasoning about the constraint that forces it. The frameworks will change, but the boundary won't: the model plans, the sandbox executes, and data crosses back exactly once, distilled.