> Building agents in 2026: piling on thicker frameworks isn't skill—treating the LLM as an ordinary component and managing it with classic engineering is.
Framework Selection: Most Teams Get Step One Wrong
Agent frameworks exploded in 2024-2025—LangChain, LangGraph, CrewAI, AutoGen, LlamaIndex, OpenAI Agents SDK, Pydantic AI—all shouting "build AI agents fast." The result: many teams default to the most complex option regardless of requirements. Even a three-step customer service bot gets a Graph, State, Nodes, Edges, and Checkpoints.
The frameworks aren't the problem—using them in the wrong place is.
LangGraph Is Strong, But Not a Universal Key
In 2026, LangGraph remains the benchmark for production agents. Its directed graph structure makes execution paths explicitly defined rather than "guessed" by the model; checkpointing enables precise recovery after crashes in long tasks; LangSmith tracing is the industry's finest-grained, showing input/output, token consumption, and latency at every step.
Q1 production benchmarks are telling: in a 4-agent collaboration scenario, LangGraph consumed ~26k tokens vs. ~52k for CrewAI and ~42k for AutoGen. On complex branching tasks (10+ steps), LangGraph used ~35k vs. ~78k (CrewAI) and ~58k (AutoGen). Error rates: LangGraph 4.7%, CrewAI 8.3%, AutoGen 12.1%. Auto-recovery success: LangGraph 89%, CrewAI 67%, AutoGen 45%.
The cost is the learning curve. A team starting from zero needs 10-14 engineer-days to become productive with LangGraph. CrewAI takes 2-3 days. For simple scenarios, that math doesn't work.
CrewAI: Great Demos, Production Cracks
CrewAI's role-driven model is intuitive—define roles, backstories, and goals for agents, and they collaborate like team members. Demos are genuinely fun: a multi-agent research pipeline in 50 lines of code.
But what production demands, CrewAI provides only reluctantly.
Production systems need deterministic fields, permission boundaries, retry-on-failure, audit logs, SLAs, and reproducibility. CrewAI's pure natural-language collaboration model tends to cause three problems in enterprise settings: runaway token costs (agents "chatting" with each other burns context—lots of "OK, I'll do it" and "thanks, let me check"), unpredictable latency (each agent's response time stacks up), and a debugging nightmare (when a task fails, it's hard to pinpoint which agent, which step).
One medical scheduling case: CrewAI compressed radiology daily-shift matching (normally 3-4 hours) by 78%, but in week two a boundary case emerged—a doctor's credentials had expired, and CrewAI's "assignment agent" didn't pause for human confirmation; it assigned an unqualified person. In LangGraph, one conditional branch solves this; in CrewAI, it takes extensive custom wrappers.
Use CrewAI for fast idea validation. Be cautious going straight to production.
AutoGen's Historical Mission Is Complete
AutoGen was historically significant in popularizing the multi-agent conversation paradigm—its "group chat" mode let agents challenge, iterate, and refine each other, effective for research tasks.
The 2026 reality: AutoGen is in maintenance mode, with Microsoft shifting resources to the Microsoft Agent Framework; the 0.4 rewrite (AG2) introduced breaking changes that frustrate existing users; multi-agent conversations cost 4-5x the tokens of LangGraph (one 4-agent task: AutoGen 56,700 tokens vs. LangGraph 13,500).
AutoGen's value was inspiration, not continuation. It proved multi-agent collaboration works; later frameworks do the engineering better.
Using the New Generation of Tools Correctly
2026 brought lighter, more focused tools—not "all-in-one frameworks" but "solutions to specific problems":
Pydantic AI: agents should have type-safe inputs and outputs. Define structured outputs with Pydantic models, validated at runtime. Great for strict structured output (forms, extraction, classification), not for open-ended conversation. Combined with Temporal, it solves long-task persistence—mid-execution API timeouts or crashes are automatically recovered, resuming exactly from the breakpoint.
Instructor: even lighter than Pydantic AI—not an agent framework but a library for "making LLMs return structured data." It wraps each provider's structured-output capabilities into a unified Pydantic model interface. 3M+ monthly downloads, the most battle-tested. For teams already on OpenAI/Anthropic SDKs who just need structured output, it's the least invasive option.
Temporal: not an agent framework, a workflow engine—but it solves production's most painful agent problem: reliable execution of long tasks (hours, days); precise recovery after failure without re-running completed steps; human-approval nodes that can "sleep" for days without consuming resources. A sensible architecture: Temporal handles outer orchestration and state persistence; Pydantic AI or native SDKs handle LLM calls; the two are separated at Activity boundaries.
Return to Software Engineering
I strongly agree with this view: the endgame of AI isn't ever-more-complex black-box frameworks—it's a return to classic software engineering.
Concretely:
- State management: use a database (PostgreSQL, SQLite), not framework-built-in State
- Long tasks: queues (Redis, RabbitMQ) plus Temporal, not framework "async"
- Structured output: Pydantic models plus Instructor, not framework output parsers
- Observability: OpenTelemetry with trace/eval/log, not "framework-bundled monitoring"
- Failure recovery: idempotent design plus retry strategies, not framework retry wrappers
- Permission boundaries: RBAC plus API gateways, not framework "agent roles"
- Simple tool calls / structured extraction / single-turn support → Native SDK (OpenAI/Anthropic) + Instructor/Pydantic AI for outputs. No framework needed.
- Multi-step workflows with explicit branches and conditions → LangGraph's Graph layer for orchestration, Pydantic AI or native SDK inside nodes. Or Temporal + native SDK if tasks are very long.
- Multi-agent collaboration with a clear process → LangGraph's Multi-Agent mode, not CrewAI's "natural-language collaboration." Each agent is a graph node; edges define collaboration rules.
- Rapid prototyping, not going straight to production → CrewAI, a demo in 50 lines. Rewrite the production version in LangGraph after validation.
- Research tasks needing agents to challenge and iterate on each other → AutoGen/AG2 or OpenAI's Swarm (educational reference). Watch costs.
- LangGraph docs: langchain-ai.github.io/langgraph
- CrewAI docs: docs.crewai.com
- Pydantic AI docs: ai.pydantic.dev
- Instructor docs: python.useinstructor.com
- Temporal docs: temporal.io
- OpenAI Agents SDK: platform.openai.com/docs/agents
- Claude Agent SDK / Managed Agents: docs.anthropic.com
The LLM should be a component being called, not the master of the system. Systems should have clear data flows, state machines, and error-handling strategies—these are software engineering fundamentals, not something agent frameworks should be teaching.
A Practical Selection Decision Tree
What Production-Grade Agents Look Like
A mature production agent system should have: schema-first design (every LLM output defined by a Pydantic model, validated at runtime); built-in observability (every LLM call, tool call, and state change traced—part of system design, not a framework "freebie"); recoverable failures (know where to retry after any step fails, not restart from scratch); controllable costs (predictable token consumption, not a surprise after the run); human intervention (critical nodes can pause for humans—no binary "fully autonomous vs. fully manual" choice); reproducible versions (same input a month later yields the same result, or the difference is recorded).
None of these depend on LangGraph. Native SDK + database + queue + Temporal achieves them too. Using LangGraph while ignoring schema and trace achieves none of them.
Final Thoughts
In 2024-2025, agent frameworks taught developers "what AI agents can do." 2026 must answer "how AI agents run reliably in production." The answer isn't in GitHub stars—it's in engineering fundamentals: type systems, database design, error handling, observability, cost management.
Frameworks are tools, not faith. Pick the right tool, then let engineering principles take over.