Clarion Street

The Agentic Framework Schism Is Over — and Control Won

·6 min read

I have written two posts about how the agent-framework argument settled, and both stopped one step short of the outcome. The first said the market consolidated into a spectrum and the decision was which primitive your workload needs, not which framework. The second said the next argument was topology, who holds state and control. Both hold up. Neither says the part that has now become obvious: the autonomy-versus-control question the debate kept circling has an answer, and it is not the one the marketing implied.

The tension was never a blog coinage. It is the organizing finding of the academic study Shi, Lee, Xu, and Wang published in the World Scientific Annual Review of Fintech in June 2025. They compared eight open-source frameworks, and the abstract says plainly that “a fundamental tension emerges between systems that prioritize agent autonomy and those emphasizing structured engineering control,” with “profound implications for system reliability, debugging complexity, and development efficiency.” Researchers named the axis before most of the vendor blogs got to it.

The two poles have clean exemplars. AutoGen is the autonomy pole: an event-driven, asynchronous loop where agents converse through messages and the orchestration emerges from the conversation. Arize describes it as chat-style coordination where agents talk until a result emerges. LangGraph is the control pole: an explicit state graph of nodes and edges with checkpointed, resumable state, at the cost of a steeper learning curve. Anthropic drew the same line earlier and more abstractly in December 2024, splitting the field into workflows, “systems where LLMs and tools are orchestrated through predefined code paths,” and agents, “systems where LLMs dynamically direct their own processes and tool usage.” Autonomy and control are two names for the same decision: who picks the next step, the model or the code.

The part the usual framing missed is that one of these poles already lost. AutoGen is in maintenance mode. Its README banner, updated in April 2026, says the project is now community-managed and points to Microsoft Agent Framework as the actively supported successor, and the repo still shows 61.4k stars. The maintenance status is a fact. Why it happened is my reading, not something the README states. My read is that behavior which emerges from conversation is hard to debug, hard to reproduce, and hard to defend in front of someone asking why a production failure happened, so the teams that had to operate these systems in production kept reaching for a control surface. LangGraph added durable execution and checkpointing, which turned a control-flow diagram into something you can pause, inspect, and resume.

But “control won” is not the whole sentence. A third pole emerged that fits neither side, and it is the one every comparison names once and then drops. PydanticAI’s control surface is not a graph. It is the type system. The agent’s output type and its tool schemas are Pydantic models, so tool arguments are validated before your code runs and every run comes back validated and typed. The loop is typed and extensible. The model reasons as freely as it wants in the middle, and structure gets enforced at the boundaries, where the tool arguments and output are validated at runtime against the Pydantic models, rather than by a state machine you drew by hand.

That is a real third answer to the schism, and it is subtler than the first two. You are not choosing between a crew of autonomous actors and a workflow of deterministic nodes. You let the model reason in the middle and put the guardrails at the edges, where runtime validation against the typed interfaces catches a bad tool call or a malformed output before it becomes a runtime failure. A graph says what happens next. A type says what a valid answer and a valid tool call look like, and it leaves what happens next to the model until the result crosses a boundary. That is control without a state machine you drew by hand, and it is the reason I would bet on the type system rather than the graph for most production work.

DSPy is a fourth answer that never entered this argument. It is eval-driven, optimizing a pipeline rather than exposing a control-flow graph. The fight that mattered was between conversation, graph, and type.

The sharpest evidence that the schism was never really a schism is what happened next. PydanticAI now ships Pydantic Graph, described in its own docs as typed control flow. The typed camp added a graph. The graph camp has been absorbing role and handoff primitives for a year. When the pure-autonomy framework is in maintenance mode and the pure-type framework adds a graph, the honest description of the last two years is a menu of primitives recombining rather than a schism. The primitives that encode state and validation kept compounding, and the one that left everything to conversation is the one now in maintenance mode. My spectrum post caught this convergence from the framework side, and the type system shows the same convergence from the control-plane side.

Three caveats keep this honest. The “control won” reading is my synthesis, not a measurement. The evidence is maintenance-mode status plus convergence, and CrewAI, which sits closer to the autonomy pole, remains active, so it is not a clean sweep. PydanticAI’s “typed end to end” and “every run comes back validated” are the vendor’s own words, not an independent assessment, and the World Scientific paper is paywalled, so I am working from its abstract and references rather than its framework-by-framework findings. There is also a defensible counter-reading: the schism never resolves because the axes are orthogonal. Autonomy is a property of the task, control a property of the runtime, so “who won” is the wrong question. I have some sympathy for that. My answer is that the direction is still visible in which READMEs are being updated and which ones are not, even if “who won” overstates it.

My read is that the interesting decision is no longer autonomy versus control. It is which control plane you want. A graph is one control plane, and a type system is another that has been hiding in plain sight under the label “typed Python” while the frameworks argued about topology. If I were starting a production agent today I would not ask whether to let the model run free. I would ask where the guardrails live, in a diagram or in the types.

Sources

  1. Comparative Analysis of Open-Source Frameworks for Agentic AI Systems — World Scientific Annual Review of Fintech
  2. Comparative Analysis of AI Agentic Frameworks — Navveen Balani
  3. Best AI Agent Frameworks in 2025 — LangWatch
  4. Orchestrator-Worker Agents: A Practical Comparison of Common Agent Frameworks — Arize
  5. Building Effective Agents — Anthropic Engineering
  6. Pydantic AI — Pydantic
  7. microsoft/autogen — GitHub