Where Agents Are Going (2026 Snapshot)

Lesson 13 · Module 6 · Choosing & Shipping · ~10 min read · Finale

1. What this lesson is and isn’t

This is a snapshot — a deliberate calibration of where the agent-building field stands in 2026 Q2, across the dimensions that matter for someone who just finished twelve lessons of hands-on agent work. It is not a prediction. Predictions in this space have a six-month half-life, and confidently-wrong predictions are a worse signal than honestly-uncertain ones. The lesson is structured around four buckets: settled (high-confidence claims that have held up for more than twelve months), unsettled (active disagreements with no obvious winner), changed recently (deltas from the last twelve months), and watch list (things that might matter in the next twelve). If a claim moves between buckets by the time you re-read this in 2027, that’s expected — and the reason the L11 scorecard is reproducible: the apparatus is what survives.

2. What’s settled

Three claims are confident enough to bet on:

• The agent loop is converged. Every serious framework — Claude Agent SDK, LangGraph, OpenAI Agents SDK, CrewAI — wraps the same loop shape we built by hand in L02: prompt → tool calls → observations → prompt, with turn caps and a stop condition. The differences are in syntax, observability surface area, and what’s overridable; not in the fundamental loop structure. If you understand L02, you understand the runtime of every framework in this course.
• Tool use is the killer primitive. MCP standardised it across vendors during 2025, which means tool implementations are now mostly portable. The interesting work has shifted from building an agent runtime to designing good tool surfaces — idempotent calls, narrow contracts, sensible error shapes, machine-readable schemas. The agent runtime is increasingly a commodity; the tool library is the moat.
• Cost and turn caps are non-optional in production. Every framework ships them as first-class config. Anyone arguing “we’ll just monitor cost” is one runaway loop away from learning otherwise. Caps belong at deploy time, not at incident time.

These three are stable enough that a course covering them in 2026 Q2 won’t feel embarrassing in 2027 Q2. If you remember nothing else from Module 6, remember the loop, the tool surface, and the caps.

3. What’s still unsettled

Three live debates with no obvious winner yet:

• Multi-agent orchestration shape. CrewAI’s role-play, LangGraph’s explicit DAG, OpenAI Agents SDK’s runner-with-handoffs — all three coexist because none is obviously correct for the general case. Each has a sweet spot: role-play for human-shaped collaboration, DAGs for control-flow you can draw on a whiteboard, handoffs for triage trees. Expect more experimentation, not less. (Bonus reading: the “agent committee” papers from 2025.)
• Eval methodology for agents. LLM-as-judge has spread fast but the failure modes are real — judge drift between model versions, position bias, prompt sensitivity, and the always-present risk that the judge and the candidate share a common ancestor. No clear winner among held-out test sets, LLM-as-judge with reference answers, or task-completion checks against a real environment. Most teams use a blend. Most blends are under-documented.
• Long-running memory. Every framework has something — summarisation, vector stores, conversation buffers, structured scratchpads. None has the equivalent of a great database: predictable indexing, easy recall, principled forgetting. This is the area most likely to see a breakthrough product in 2026 H2, and the area where today’s code is most likely to look quaint in 2027.

4. What changed in 2025–2026

The deltas of the last twelve months that the rest of the course already reflects:

• MCP standardisation (2025). The unlock most worth naming: tools written for one agent now work for others. The four frameworks the course covers all gained first-class MCP support during this window. L12’s sidebar on the MCP bridge is a direct consequence.
• Anthropic’s Computer Use → Claude Agent SDK rebrand (2025). General-purpose agent primitives became the headline; computer-use tools became one option of many. L03 reflects the post-rebrand shape.
• OpenAI Agents SDK GA (2025 Q3). What had been a research-grade SDK shipped as a production-supported product, including the Runner.handoff() primitive L08 exercises.
• LangGraph 1.0 (2025 Q4). Stable APIs, a viable production story, and much better tracing via LangSmith. L06’s graph would have needed asterisks a year earlier; it doesn’t now.
• CrewAI multi-process execution (2026 Q1). Sub-agents can now run in separate processes, which isolates crashes and unblocks parallelism the in-process runner couldn’t reach.
• A2A / ACP drafts (2026 Q1). First plausible specs for inter-agent communication across process boundaries. Adoption today is minimal — most multi-agent work still happens inside one process — but the specs are circulating in earnest and worth tracking.

5. What to watch in 2026 H2

The author’s bets, all low-confidence and offered as a calibration check rather than as a forecast:

• A2A / ACP adoption. If inter-agent protocols take off, “agent framework” becomes a different problem — frameworks become clients of a mesh, not isolated runtimes. Likely too early to act on; worth tracking quarterly.
• Eval standardisation. A “promptfoo-but-for-agents” winner would change how teams reason about agent quality across releases. Several candidates exist; none is dominant. If one consolidates, the L11 harness gets a successor and the scorecard rubric becomes a config file rather than Python.
• Local-first agents. Open-weight models running on consumer hardware. The economics flip when you can run a Sonnet-grade agent on a laptop — latency drops to single-digit milliseconds for the loop overhead, cost per task approaches zero, and a class of privacy-sensitive deployments becomes feasible. Watch Llama, Mistral, and Qwen release cadences.
• EU AI Act phase 2. Agent-specific provisions land in 2026 H2. Compliance work begins now for teams shipping in EU markets — particularly around traceability, kill switches, and the documentation of automated decisions.
• The “agent OS” idea. A few teams are reframing the agent runtime as something closer to an operating system: scheduling, sandboxing, permissions, resource quotas. Could be 2027’s big shape change; too early to invest deeply in any one implementation.

6. The warning

7. Closing — and a thank-you

You came in twelve lessons ago without (necessarily) an opinion on agent frameworks. You leave with hands-on experience of four, a reproducible scorecard for comparing them on your own questions, and an instinct for which dimensions matter for which projects. That’s the actual deliverable of the course — not the rankings, which will move, but the apparatus that gives you new rankings whenever the field moves.

The most valuable thing the course gives you is the vocabulary: the eval harness, the cost / latency / quality triple, the bridge to MCP, the discipline of measuring against a fixed task set. When the next framework lands in 2027 — and it will — you’ll know how to slot it into the harness and answer “is it better than what I have now?” with numbers rather than vibes. That’s a durable skill in a field that isn’t.

Now go build something. And — when you find a framework number that’s drifted, or a claim in this lesson that’s aged poorly, please file an issue against the repo. The course wants to age well; that takes readers.

References

• All twelve prior lessons of this course — L01, L02, L03, L04, L05, L06, L07, L08, L09, L10, L11, L12.
• agents/_eval/ — your starting harness for re-comparison. Re-run it against a new framework before you migrate.
• Anthropic, OpenAI, LangChain, and CrewAI release notes for the cited 2025–2026 deltas.
• EU AI Act phase 2 timeline — for the regulation watch-list item.

LAST-REVIEWED: 2026-05-25