January 2026, Revisited: Agent Frameworks Grow Up

This post is part of our Three-Year Retrospective series: thirty-six posts, one per month, looking back at what actually mattered in software engineering. This one covers January 2026.

January 2026 didn't have a single headline release, and that's exactly why it earns a spot in this series. It was the month the agent-framework conversation changed register. Pydantic AI had reached its stable v1 in September 2025; LangGraph and the rebuilt LangChain had hit 1.0 in October. By January, both had a quarter of post-1.0 production mileage behind them, the early-adopter war stories were in, and the question we heard from teams shifted from "which framework is winning?" to "which framework fits this system?" Boring questions are how a technology category announces it has grown up.

What stability actually bought

It's worth remembering how chaotic 2024 and early 2025 had been in this space. Frameworks broke APIs casually, abstractions churned quarterly, and a sizable contingent of experienced engineers concluded — not unreasonably — that the only safe framework was no framework. The v1 releases were aimed squarely at that skepticism. Pydantic AI's v1 came with an explicit API-stability commitment: no breaking changes until v2. LangChain's 1.0 was a deliberate slimming — a smaller, agent-focused core built on top of LangGraph's runtime, shedding years of accumulated abstraction. For platform teams who had to write internal standards documents, "stable, versioned, with a deprecation policy" was the actual feature.

January's production reports confirmed the frameworks were holding up, and they also clarified what each one was for — which brings us to the selection criteria.

Durable state versus typed DX

The shorthand we settled on in our courses that month: LangGraph sells durable state, Pydantic AI sells typed developer experience.

LangGraph's center of gravity is the graph runtime: checkpointing every step to a store, so a workflow can crash, resume, time-travel, or wait days for a human approval without losing its place. If your agent system is really a long-running, interruptible business process — multi-step document pipelines, human-in-the-loop approvals, anything where "resume from step 7" is a requirement — that persistence layer is the product, and in January 2026 nothing else matched it.

Pydantic AI's center of gravity is the type system: agents whose inputs, outputs, and tool signatures are Pydantic models, validated at the boundary, refactorable with an IDE, testable like ordinary Python. For teams whose agents are mostly request-scoped — answer this question, triage this ticket, produce this structured object — the typed-DX path produced code that ordinary Python engineers could read, review, and own. Its durable-execution story was younger, leaning on integrations rather than a native checkpointer.

The honest answer we gave, and still give: many systems need neither framework's signature strength, and a plain loop with direct API calls remains underrated. But when you do need one, the durable-state-versus-typed-DX axis sorts most decisions quickly — much faster than feature-matrix shopping. (And looming over all of it was the protocol layer: with MCP becoming the standard way to hand tools to any agent, the framework decision got smaller, because your tools stopped being framework-specific.)

Framework choice as an architecture decision

The deeper January 2026 shift was who made the decision. In 2024, agent frameworks were chosen by whoever prototyped first. By early 2026, the decision had migrated to architecture reviews, with the questions architecture reviews ask: state management, failure recovery, observability, testing strategy, team skills, exit cost. The frameworks themselves had matured into that scrutiny — and the discipline of asking those questions did more for production reliability than any individual framework feature shipped that quarter.

Looking back from June 2026

Five months on, the January picture has held remarkably steady. Both ecosystems kept shipping in their 1.x lines without breaking their stability promises, the durable-state-versus-typed-DX framing still sorts new projects accurately, and MCP's continued spread has made tool portability the norm. The framework wars didn't end with a winner; they ended with a job description — pick per system, keep tools protocol-shaped, and treat the agent runtime like any other infrastructure dependency.

If your team is making this call now, Building AI Agents with Python and MCP works through agent construction with portable, protocol-based tooling across frameworks, and Designing Multi-Agent Systems covers the architecture-review questions — state, recovery, orchestration topology — that the mature framework era demands.