The Paleozoic Era of Agentic Frameworks

Job: Head of Agentic Strategy (Location: SF / Remote / The Void)

Requirements: 7+ years experience in a field that didn’t exist 18 months ago and probably won’t exist in another 18 months.

Role: Manage a ‘workforce’ that is essentially a black box of schizophrenic digital spider monkeys with no sense of time or money.

Compensation: Competitive salary, plus equity in a company that will likely be a literal fossil by the time you vest.

Sequoia says we should “hire an agentic recruiter.” Because we are YC, we’re going even further. We need a Head of Agentic Strategy. Dynamic workplace environment. Irony unwelcome.

We are in some weird Cambrian Explosion right now. There’s a manic rush as we watch rapid proliferation of half-baked agentic frameworks like LangChain, AutoGen, CrewAI, LlamaIndex, a hundred forks and wrappers and “agent OS” plays. Blech.

99.99% of these are evolutionary dead ends.

They are circling around the same root coordination problem with differing (and wrong) solutions. None of them can name the problem concisely, and a problem well stated is a problem half solved. (One of my panoply of old bosses at BigCo said this on the regular, and it annoyed the shit out of me, but a stopped clock is right twice a day, so…) But their gene lines are doomed for extinction.

The symptoms are fairly well described: Agentic loops, memory architecture, context window management, termination conditions and cost explosions. Yet no one seems to be able to explain why these problems exist, only that they do. So they are all madly iterating in the dark, claiming they’ve fixed it, but meanwhile the great Die Out is coming. This is a fossil record hastily cataloging its own failures, hoping that will save it. It won’t.

These proto-frameworks are the trilobites in the Paleozoic Era of agentic frameworks.

None of them will survive to the Mesozoic.

Thus, let us ponder the fourfold path to agentic extinction.

Termination failure “Dad, are we there yet?” “Look, kids! Big Ben! Parliament!” The agent doesn’t know when it has arrived because it has no coordinates. You cannot terminate correctly because “done” is subjective, and without grounding (cognitive grounding) in the phenomenological space, you can’t define it. You can set a token limit, which is not termination. More like just venting the oxygen to space.

Memory… huh? “I feel like I walked into this room to do… something. What was it?” This factors in all the oopsies of lost-in-the-middle, context window mismanagement and layered memory. Context windows are a fact of life. Ya gotta work with it, which means some kind of context-window-loading is needed. But… how, when, where, how much? At what cost? More tokens helps, but it is not the answer. Try feeding it a US gov’t omnibus spending bill. “Have fun storming the castle!”

Cost explosion “I have good news and bad news. The agents worked out a nice solution. We’re also bankrupt.” Here, the flavors are API recursion, budget exhaustion, RAG latency spirals, yada yada. Without some internal economy, some accounting, some “What does this cost?” and “Is it worth it?”, then you’re flying blind. The agent can’t ask “Is this route worth 3x the cost of that one?” because it has no geometry to route through. Any “budget-aware allocator” bolted on after the fact is a circuit breaker wearing a cheap suit.

Finally the biggie: Coordination collapse. These failures look like clarification loops, sequential vs. hierarchical vs. peer-to-peer debates, orchestration trainwrecks, etc. These proto-frameworks recommend patterns without explaining (or even being aware of) why various failure modes kick in. Nobody seems to be asking: is a “coordination regime” even the right terminology? The organism is trying to solve a regime-selection problem with a pattern catalog, or any way to pick and choose among the options.

I offer this: these are all just symptoms of the same disease. The last one is the real one. Coordination failure.

Coordination collapse has a name nobody in the framework discourse is using: absence of constraint. The agent has no ground. It has task descriptions (symbols) but no constraint landscape, and thus no grounding for coordination decisions. You can’t coordinate properly because coordination requires knowing where you are relative to where you need to be, and that knowledge requires a kind of grounding to which these architectures are structurally alien.

The frameworks are treating symptoms because they cannot see the disease. You cannot fix coordination failure with a better pattern catalog any more than you can fix being lost by running faster.

What we need is a proper constraint landscape. That would be a representation in some manifold, some space (goal space) in which “research complete” (for example) is a point or area on the map, partial states have distances from that attractor, paths through the space have costs, and the agent knows (from the local geometry) whether it is converging or diverging, and how much it might cost to get there.

The difference is not academic. Without geometric ground, the agent cannot:

Know if it is approaching a solution or spiraling away from one
Price alternative paths through the problem
Select the coordination regime appropriate to the region of goal-space it currently occupies (crisis coordination, lax exploration coordination, price-based, etc., etc…)
Terminate because it has arrived or can not arrive (ie., it ran out of something… time, tokens, whatever).

This is Yann LeCun’s Configurator problem, one abstraction lower. In synthetic cognitive architecture, LeCun proposes a module that sets parameters, decomposes tasks, switches modes, allocates resources. Then, when asked how the Configurator actually learns to do this, he writes: “I shall leave this question open for future investigation.”

Near as I can tell, these Paleozoic agent frameworks have not even noticed the Configurator problem exists. They have outsourced it entirely to the LLM, which is a symbol manipulator without geometric ground trying to navigate a space it cannot represent.

The fix (as I’ve argued elsewhere at probably excessive length) is goal-space geometry. Riemannian structure in which the coordination regime is implied by the local curvature of the space, not selected by an executive.

Agent frameworks need this layer. None of them have it.

(Now, beloved reader, a brief detour, because this rhymes - loosely - with recent history.)

React (the web app framework) emerged because the web had solved its foundational problems. HTTP was stable. The DOM was understood. State management was the remaining hard problem. React could make opinionated choices because the surface beneath it was firmly underfoot.

I see parallels. MCP is HTTP circa 1996. The protocol layer isn’t going to stabilize for some time because MCP is a hot, hot mess. It’s better than nothing. I guess. But the proponents of MCP seem to lack even a passing familiarity with the failures littering the trail. RPC? ESB? SOAP? CORBA? Early REST? GraphQL? Need I continue? CORBA was technically elegant the way a guillotine is elegant; impressive until you’re the one in it. MCP is neither elegant nor impressive.

This “framework moment” requires someone who has built enough production agents to know what the abstraction should be. (That is, what the hard problem demands. Cuz yes, it’s hard. Much harder than MCP makes it out to be.) That person is accumulating scar tissue right now. Their production agents are terminating wrong and costing $34,000 for wrong answers and looping through clarification spirals.

The “React for agents” will not come from any of the current framework teams. It will come from someone who read the fossil record carefully and groks what is needed to live through the extinction event.

18 to 36 months. Maybe. If the coordination layer (geometry) gets figured out.

Dijkstra’s Go To Statement Considered Harmful was not an argument that control flow is bad. It was an argument that control flow without structure introduces failure modes that compound faster than they can be diagnosed.

I submit: in 2026, agentic solutions are considered harmful. Not because the vision is wrong. The vision on point. Autonomous coordination of cognitive agent-things is nifty. (I think.) But the current frameworks apply the abstraction before the field understands what it is abstracting over. (Viz: Rule of Three.)

The practical consequence is very zeitgeisty, in a late-capitalism, sprint-for-first-mover-advantage sort of pathetic way: shipping systems with no termination guarantees, no auditable decision paths, no legible state, and no transparent cost model. When they fail (and they will fail, probably making headlines) ya can’t explain why. ::shrug:: “It’s a statistical approach to success.”

Cue the financialization.

…MASSIVE ASIDE HERE…

Recall the 2008 CDO structure: bundle up a bunch of individually risky mortgages, butcher them into tranches, sell the risk to ~~suckers~~ people who don’t understand what’s inside, collect fees, and when the underlying assets all fail correlated, the whole structure collapses simultaneously because the diversification was fake. Meanwhile you’re on a beach in Tahiti.

The agentic version will run identically: bundle up a bunch of individually unreliable agent workflows, wrap them in an “agentic platform” or “AI infrastructure” product, then sell enterprise contracts to buyers who can’t understand (much less audit) what’s inside, collect ARR, and when the underlying agents all fail in some synchronous, correlated way (same missing geometry, same absent termination guarantees, same no-cost-model) the enterprise customer is holding paper that was never worth what they paid. Meanwhile you’re on a beach in Tahiti.

[Aside aside… waitasec. Maybe this is a startup I could get behind!]

The CDO had ratings agencies blessing dogshit. The agentic equivalent is benchmark scores. “Achieves 87% on GAIA.” The benchmark measures tasks with verifiable endpoints. Production doesn’t have verifiable endpoints.

The term is Collateralized Agent Obligations (CAOs). Tranched by “autonomy level” or “task complexity tier.” Senior tranche: deterministic workflows with LLM garnish. Mezzanine: semi-agentic with human-in-the-loop. Equity tranche: fully autonomous, no oversight, pure vibes.

The equity tranche is what everyone’s selling.

…THE ASIDE ENDETH…

Anyhow, I’m wrapping this shit up. The punchline writes itself: we know how this movie ends. Final Fantasy 237.

Meanwhile, I’m over here. Regular ‘ole coded deterministic coordinators are boring. They are structured programming to agentic GOTO. They have good old fashioned properties that agentic systems in 2026 do not: legible state, predictable cost envelopes, auditable decision paths, termination guarantees. In my view, these are not “nice-to-have”. They are the difference between a system and a liability that occasionally produces correct output.

Back to the analogy: the trilobites were impressive. Extraordinarily successful for their moment! The Permian extinction didn’t care.

So, friend: build the deterministic coordinator. Document the failure modes it can’t handle. That documentation is the fossil record the next era’s frameworks will be built from.

The Permian Extinction is coming.

Colin Steele is a former CTO and F500VP and now a ‘fractional’ (exactly nine sixteenths) COO who has shipped exactly zero agentic frameworks and dines on trilobites at colinsteele.org. He builds deterministic coordinators because he is old and boring and they work.