Multi-Agent vs Single-Agent: When More Agents Actually Help
Two of the most-cited essays on agent design say opposite things. They are both right — the disagreement is really about whether your task reads or writes.
5 min
Every AI Agent Framework Became a Graph in 2026 — and the Hard Part Is Still Unsolved
With ADK 2.0's GA, LangGraph, OpenAI's Agents SDK, Google's ADK, and Microsoft's Agent Framework all now run on a graph execution engine. The programming model war is over. It settled the easy question.
5 min
LangGraph vs CrewAI vs AutoGen: How to Choose an Agent Framework in 2026
All three claim to build multi-agent systems. The real question isn't features — it's who owns the control flow, and the answer changes which one is the right call.
4 min
Agno vs LangGraph vs CrewAI: Choosing an Agent Framework in 2026
All three build Python agents, but they disagree on one thing — who owns the loop. That contract, not the benchmark, is what you live with for years.
5 min
smolagents vs LangGraph vs CrewAI: Three Bets on How an Agent Acts
The frameworks that get the most attention disagree on something basic — what an agent's action even is. One writes code, one wires a graph, one casts a team.
5 min
OpenAI Agents SDK vs Pydantic AI vs Google ADK: The New Frameworks, Compared
The second wave of agent frameworks is leaner, typed, and vendor-backed — and underneath the branding, they're quietly converging on the same idea.
5 min
Claude Agent SDK vs LangGraph: Inherit a Loop or Own the Graph
One hands you Anthropic's production agent loop already wired up; the other hands you a blank graph and a state machine. The choice is less "which framework" than "how much of the loop do you want to own."
5 min
Google ADK vs LangGraph: Which Agent Framework Should You Build On in 2026?
Both will run the same agent. The real difference is altitude — ADK hands you an org chart of agents, LangGraph hands you the wiring and a roll of tape.
4 min
ADK 2.0 Turns Agents Into Graph Nodes: Inside Google's Workflow Runtime
Google's Agent Development Kit shipped a graph-based execution engine — and quietly retired the org-chart of agent types that used to be its whole pitch against LangGraph.
4 min
LangGraph vs Microsoft Agent Framework: Who Owns the Run Loop in 2026
They ship the same orchestration patterns now, so stop comparing them on patterns. The real fork is where your production agent actually runs — in code you hold, or in a cloud you rent.
4 min
LangChain vs LangGraph: You're Choosing a Layer, Not a Side
Since the 1.0 release, LangChain's agent helper runs on LangGraph's engine — so the real question isn't which to pick, but which layer of the same stack to write against.
5 min
LangChain 1.0 and LangGraph 1.0: What Actually Changed for Agent Builders
After a year of churn that made it a punchline, LangChain shipped a 1.0 whose headline feature is the thing frameworks never promise: that it will stop moving under you.
4 min
What Are Deep Agents? The Four-Part Pattern Behind Long-Horizon AI Agents
A deep agent is not a new model or a framework breakthrough — it's four cheap, known ingredients that let a plain tool-calling loop survive a long task instead of drifting.
5 min
Deep Agents on Pydantic AI: The Repos for a Self-Hosted, Model-Agnostic Claude Code
Claude Code proved the 'deep agent' pattern — planning, a filesystem, sub-agents, skills. A small cluster of Python repos now rebuilds that harness on Pydantic AI, so it runs on any model you own.
4 min
LangChain's Deep Agents Now Ships Its Own Coding Agent — and Speaks ACP
In early July, Deep Agents quietly split into three shippable packages: a model-agnostic harness, a terminal coding agent, and an ACP adapter. The library became a product line — and unbundled the coding agent from both the model and the editor.
4 min
Orchestrator-Worker vs Pipeline vs Swarm: How to Choose a Multi-Agent Topology
The three multi-agent shapes aren't ranked best-to-worst — they're a single axis. Pick by one question: how much context can you afford to lose between agents?
4 min
Supervisor vs Swarm vs Handoffs: Multi-Agent Orchestration Patterns in 2026
The topology you pick for your agents is really one decision in disguise — who holds the state and the control — and that single choice sets your token bill, your latency, and whether you can ever debug the thing.
5 min
Claude Code Nested Subagents: The Depth Cap Is 5, but Your Token Bill Is the Real Limit
Subagents can now spawn subagents five levels deep. The number that decides whether you should is not the depth — it's how much billed work happens at branches the root never reads.
4 min
How to Cap an AI Agent's Spend per Run (max_tokens Won't Save You)
The parameter everyone reaches for limits the size of one reply. Agent bills don't blow up on reply size — they blow up on the number of replies. Cap the loop, not the token.
5 min
Why DSPy Rebuilt ReAct: The Trajectory String Was Quietly Breaking Prompt Caching
DSPy's ReActV2 looks like a native-tool-calling upgrade. The real fix is deeper — the classic ReAct loop re-serialized its whole scratchpad into one prompt every turn, which silently defeated provider prompt caching. Moving to structured history cut cost up to 50%.
4 min
CrewAI Flows vs Crews: When to Let Agents Decide and When to Script Them
CrewAI ships two orchestration models in one framework. Picking wrong is why your multi-agent demo worked and your production run didn't — and the fix is usually not choosing between them.
4 min
CrewAI 1.14's Pluggable Backends: The Framework Is Un-bundling Its Storage
CrewAI 1.14 lets you swap the default memory, knowledge, RAG, and flow backends for your own. It reads like a config change. It's actually the framework conceding that batteries-included storage was a production liability.
4 min
CrewAI Conversational Flows: What 'Chat' Actually Adds to a Crew
CrewAI 1.15 shipped conversational flows, and it's easy to read that as "your crew can hold a conversation now." It can't. What shipped is a persisted, resumable flow behind a poll loop — and that distinction decides how you build.
4 min
Agent Handoffs in LangGraph, OpenAI Agents SDK, and Google ADK: What Actually Transfers With Control
Every multi-agent framework now has a handoff primitive, and they all look the same in the demo. The difference that bites you in production is what rides along when one agent passes the baton to the next.
5 min
From Framework to Harness
The agent libraries that mattered in 2024 told the model what to do next. The ones that matter now assume it already knows — and sell you the restraints and the trace instead.
4 min
Omnigent: Databricks' Meta-Harness for Running Claude Code, Codex, and Cursor as One Layer
Databricks open-sourced a common orchestration layer over Claude Code, Codex, Cursor, and your own agents — swap the harness in one line of YAML. The interesting bet isn't portability. It's who reviews the code.
5 min
LangGraph Checkpointing vs Temporal: Why Checkpoints Aren't Durable Execution
Most teams assume LangGraph's checkpointer already makes their agents crash-proof. It doesn't — and the gap is architectural, not a missing setting. Here's exactly where it ends and where Temporal begins.
4 min
LangGraph's DeltaChannel: The Hidden Quadratic Cost of Durable Agents
Every checkpoint a long-running LangGraph agent writes re-serializes its entire state. DeltaChannel, per-node timeouts, and the v2 stream in 1.1–1.2 are the runtime quietly admitting the naive durability model doesn't scale.
4 min
LangGraph Node Timeouts: run_timeout vs idle_timeout for Agent Nodes
LangGraph 1.2 shipped per-node timeouts with two knobs that look interchangeable and aren't. Pick the wrong one and you either kill healthy slow work or never catch the hang you added it for.
5 min
LangGraph Node Error Handlers: Saga Compensation, and Why It Isn't a Timeout
LangGraph 1.2 gives a node three ways to fail — timeout, error_handler, drain. They look similar and do opposite things to your state. Mixing them up corrupts compensation.
4 min
Making a Pydantic AI Agent Crash-Proof: Temporal vs DBOS vs Prefect vs Restate
Pydantic AI now speaks four durable-execution backends with near-identical code. That means the choice isn't about the framework — it's about which piece of infra you're willing to run.
4 min
Webhooks vs Polling for Long-Running Agent Tasks: Why Agents Reversed the Default
For a decade the advice was "stop polling, use webhooks." The agent runtime quietly broke the webhook's core assumption — so the newest async surfaces ship polling first.
5 min
Mastra vs Vercel AI SDK vs LangGraph.js: TypeScript Agent Frameworks in 2026
The three names a JavaScript team keeps hitting when it tries to build an agent aren't competing for the same job. Two of them stack on top of the third.
4 min
Why AI Agents Ignore Their Own Instructions — and How Parlant Enforces Them
A system prompt is a broadcast: every rule you add competes with every other rule for the model's attention, on every turn. Parlant's bet is that reliability is a context-assembly problem, not a prompt-writing one.
6 min