Agents Arch

Five months of weekly posts; five trends worth watching. What 2026 settled, what it didn't, and the architectural bets I'd make if I were starting now.

Eighteen weeks of patterns combined into one production-shaped architecture. The full diagram, the repo layout, the contracts between components, and the migration sequence.

Four agent frameworks, four different bets. The honest comparison — what each gets right, where each leaks, and the decision tree for picking one (or composing several).

When one agent isn't enough, hierarchy is usually the first answer. Supervisor agents, worker pools, and the patterns that keep multi-agent systems coherent at scale.

Who decides what agents are allowed to do, how those decisions get enforced at runtime, and how to prove it later. The 2026 governance stack — policy as code, audit trails, and the EU AI Act bit.

Agents are systems that take instructions from untrusted text and execute actions. The 2026 threat model — prompt injection that's not solved, tool sandboxing, scoped credentials, and authorization that survives contact with the LLM.

Agents bill non-linearly. The patterns that matter — prompt caching, tiered model routing, parallel tool calls, retrieval budgets — and the dashboards that catch waste before it ships.

Three deployment shapes for production agents — request/response, long-running stateful, and background batch — with the trade-offs around Cloud Run, Kubernetes, managed runtimes, and queue workers.

You can't ship agents you can't measure. The 2026 eval stack — task-level scoring, trajectory grading, LLM-as-judge with calibration, and the regression gates that catch silent quality drops.

Agents are non-deterministic stateful systems calling external services. You cannot debug them without tracing. The 2026 observability stack — LangSmith, Langfuse, OpenTelemetry — and the metrics that matter.

RAG for agents is not RAG for chatbots. Hybrid retrieval, query rewriting, retrieval-as-tool, and the patterns that beat 'top-k from a vector store' in 2026.

When one agent isn't enough, how do they talk? A2A for peer-to-peer delegation, MCP for tools, and the durable message-bus patterns underneath multi-agent systems in 2026.

Tools are what turn a chatbot into an agent. The 2026 stack for tool design — small scoped tool sets, structured arguments, MCP servers, and the failure modes you only see in production.

Three kinds of memory, four-tier consolidation pipelines, hybrid retrieval that beat pure vector search, and the unsolved staleness problem. The 2026 state of the art for agents that learn over time.

Claude Managed Agents and Amazon Bedrock AgentCore turned 'run an agent in production' from a months-long platform project into a credit-card decision. Here's how they differ and when each wins.

Google's Agent Development Kit isn't another agent loop. It's an event-driven runtime, a multi-language SDK, and a deploy target that lines up with Cloud Run and GKE. Here's how the pieces fit.

Crews, Flows, and the dual-layer architecture that lets CrewAI hold its own against LangGraph in 2026 — when role-based composition is the right abstraction and when it isn't.

The three control-flow patterns that turn a toy LangGraph agent into a production system — bounded cycles, parallel fan-out/merge branches, and interrupt-resume human approval gates.

LangGraph turns the agent loop into an explicit state graph — nodes, edges, reducers, checkpointers. The mental model, the type system, and the patterns that make it production-grade.

LangChain is no longer the agent framework — LangGraph is. But its primitives (runnables, retrievers, callbacks) became the connective tissue underneath. Here's what to keep and what to drop in 2026.

What actually goes inside a production AI agent — the reasoning loop, the tool layer, memory, control flow, and the surface where models meet your business systems.