Ecosystem Map: SDKs, Graph Runtimes, Workflow Runtimes, Multi-Agent Runtimes

Overview

You've built a custom harness from scratch. You traced eight concerns — state, routing, tools, errors, events, interrupts, delegation, and persistence — from first principles through production features. Now you'll see how the industry solves the same problems.

This lesson compares real-world harnesses across the eight-concern framework you learned in Lessons 1–8. You'll categorize frameworks, read a side-by-side comparison table, understand the "Custom" column, track ecosystem evolution, and identify trend lines that matter for production deployments.

The Big Seven Frameworks

The agent harness ecosystem has converged around seven major frameworks as of mid-2026, each representing a distinct runtime model. Rather than learning each framework in isolation, we compare them across the eight harness concerns you studied in Lessons 1–8.

1. Microsoft Agent Framework (MAF)

MAF 1.0 (GA April 2026) is the unified successor to AutoGen and Semantic Kernel. It ships with native MCP and A2A protocol support for both .NET and Python. MAF combines AutoGen's conversational multi-agent abstractions with Semantic Kernel's enterprise features — session-based state management, middleware, telemetry, and type safety — and adds graph-based workflows for explicit control over multi-agent execution paths.

Runtime model: Enterprise SDK with graph workflows, middleware pipeline, and protocol-native integrations (MCP + A2A).

2. LangGraph

LangGraph models agents as state graphs with explicit nodes (steps), edges (transitions), and typed state schemas. It provides checkpointers for durable execution, interrupt nodes for human-in-the-loop, and time-travel debugging by replaying from any checkpoint.

Runtime model: State graph runtime with checkpointers, stores, and visual debugging.

3. OpenAI Agents SDK

A managed SDK with a small API surface: you define agents, tools, and handoffs. The SDK manages the inner loop, server-side thread persistence, streaming, and tracing. Despite the name, it supports non-OpenAI model providers.

Runtime model: Managed cloud SDK with server-side state and agent handoffs.

4. Google Agent Development Kit (ADK)

A code-first toolkit for defining agents, tools, sessions, memory, evaluations, and multi-agent patterns. ADK is protocol-native: it ships with MCP integration for tool discovery and A2A support for cross-framework agent communication. Gemini's multimodal capabilities open use cases that text-only frameworks cannot address.

Runtime model: Code-first protocol-native SDK with MCP + A2A and multimodal support.

5. Claude Agent SDK / Claude Code Runtime

Anthropic's SDK takes a tool-use-first approach where agents are Claude models equipped with tools, including the ability to invoke other agents as tools. The architecture is deliberately minimal: an agent loop receives a prompt, calls tools as needed (including sub-agent tools), and returns a response. Claude Code extends this with permission systems, context compaction, MCP/plugins/skills/hooks, subagents, and append-oriented session storage.

Runtime model: Tool-use-first coding-agent runtime with hierarchical subagent spawning and MCP integration.

6. CrewAI

CrewAI models teams of agents with roles, goals, and delegation. You define a crew (e.g., researcher + writer + reviewer), assign tasks, and let agents delegate subtasks to each other. Fastest path to multi-agent prototyping, with pluggable memory/knowledge/RAG backends.

Runtime model: Role/team multi-agent framework with task delegation and pluggable backends.

7. Mastra

A TypeScript-first agent framework (from the Gatsby team) with built-in workflow orchestration, a dedicated Studio IDE for development and debugging, a Memory Gateway for persistent agent memory, and MCP support. Represents the JS/TS agent-app stack.

Runtime model: TypeScript workflow-agent framework with Studio IDE and Memory Gateway.

Related and Adjacent

These are not among the Big Seven but appear in production agent stacks:

• AG2 / AutoGen lineage — the predecessor to MAF's multi-agent abstractions; now in maintenance mode with community forks. Relevant for understanding how multi-agent patterns evolved.
• Semantic Kernel — the predecessor to MAF's enterprise features; merged into MAF 1.0. Relevant for .NET-heavy environments still running pre-MAF code.
• Vercel AI SDK — React hooks and streaming UI components for integrating LLM agents into frontend applications. Not a harness itself, but a common UI layer atop agent SDKs.
• Temporal — a durable execution platform with exactly-once semantics. Hosts agent steps as workflow activities. Use when agents are part of larger distributed workflows requiring transactional guarantees.
• Prefect / Airflow — workflow orchestrators for data pipelines. Can embed LLM agent steps but lack interactive session continuity.

graph TD
  subgraph SDK["SDK-Style"]
      OAI["OpenAI Agents SDK"]
      CLAUDE["Claude Agent SDK"]
  end
  subgraph GraphRT["Graph-Based"]
      LG["LangGraph"]
  end
  subgraph MultiAgent["Multi-Agent"]
      CREW["CrewAI"]
      MAF["MAF 1.0"]
  end
  subgraph FullStack["Full-Stack"]
      ADK["Google ADK"]
      MASTRA["Mastra"]
  end
  MAF ---|"MCP + A2A"| ADK
  CLAUDE ---|"MCP"| MAF
  ADK ---|"MCP"| CLAUDE
  OAI -.- LG
  CREW -.- MASTRA

  style SDK fill:#e3f2fd,stroke:#1976d2
  style GraphRT fill:#f3e5f5,stroke:#7b1fa2
  style MultiAgent fill:#fff3e0,stroke:#f57c00
  style FullStack fill:#e8f5e9,stroke:#388e3c

Comparison Table

The table below maps the runtime model, the eight harness concerns, deployment model, and protocol support across the Big Seven frameworks plus Custom. Each cell summarizes how the framework addresses the concern.

| Concern | MAF 1.0 | LangGraph | OpenAI Agents SDK | Google ADK | Claude Agent SDK | CrewAI | Mastra | Custom | |---------|---------|-----------|-------------------|------------|------------------|--------|--------|--------| | Runtime Model | Enterprise SDK with graph workflows | State graph runtime | Managed cloud SDK | Code-first protocol-native SDK | Tool-use-first coding-agent runtime | Role/team multi-agent framework | TypeScript workflow-agent framework | Developer-defined | | State Management | Session-based state with middleware | State graphs with typed schemas | Server-side threads | Session and memory primitives | Append-oriented session storage | Role-based agent state | Workflow state with persistence | Developer-defined | | Routing Logic | Graph workflows + conditional edges | Graph edges with conditionals | Handoffs between agents | Agent routing with A2A | Tool execution routing in agent loop | Task delegation router | Step-based workflow routing | Developer-defined | | Tool Integration | Native MCP + function schemas | LangChain wrappers + MCP adapters | Function calling schema | Native MCP + A2A tool discovery | Tool definitions + MCP servers | Tool integration per agent | Tool definitions with MCP | Developer-defined | | Error Recovery | Middleware + retry policies | Retry nodes + error edges | Retry policies + thread continuity | Built-in retry with error handlers | Checkpoint-based recovery | Task retry + fallback agents | Step retry with error handlers | Developer-defined | | Event Tracing | Built-in telemetry + middleware | LangSmith tracing | API events + logs | Cloud Trace integration | Event hooks + session logs | Task logs | Built-in observability | Developer-defined | | Interrupts | HITL middleware | Interrupt nodes in graph | No native support | HITL primitives | Permission gates + session pause | Human-in-the-loop tasks | Workflow pause/resume | Developer-defined | | Delegation | A2A protocol + multi-agent graphs | Subgraph invocation | Agent handoffs | A2A for cross-framework delegation | Hierarchical subagent spawning | Crew task delegation | Multi-step workflow delegation | Developer-defined | | Persistence | Session store + external backends | Checkpointers (memory, SQLite, Postgres) | Server-side thread storage | Session persistence + memory store | File checkpointing + session continuity | Task state persistence | Workflow state persistence | Developer-defined | | Deployment | Self-hosted or Azure | Self-hosted with optional cloud | Managed cloud service | Self-hosted or Google Cloud | Local or self-hosted | Self-hosted | Self-hosted or serverless | Developer-defined | | Protocol Support | Native MCP + A2A | LangChain wrappers + MCP adapters | OpenAI function calling | Native MCP + A2A | Anthropic tool_use + MCP | Framework-agnostic | MCP support | Developer-defined |

Reading the Comparison Table

The comparison table maps how each framework addresses the eight concerns. Understanding how to read the table helps you evaluate frameworks for your requirements.

Start with the Runtime Model row. This row tells you the fundamental shape of each framework: is it a state graph, a managed cloud service, a coding-agent runtime, or a team-based framework? The runtime model determines what kind of customization you do — configuring graph edges vs defining agent roles vs writing loop logic.

Cell Semantics: Each cell shows the framework's approach to a concern, not a quality rating. "Session-based state with middleware" (MAF) is different from "State graphs with typed schemas" (LangGraph), but neither is inherently better — they reflect different design philosophies and deployment models.

Managed vs Native vs None:

• Native: The framework handles the concern as a first-class feature. Example: LangGraph provides checkpointers for persistence; MAF provides native A2A for delegation.
• Supported: The framework provides hooks or adapters. Example: LangGraph has community MCP adapters; CrewAI supports human-in-the-loop tasks.
• None: The framework doesn't support the concern. Example: OpenAI Agents SDK has no native interrupt primitives.

The "Developer-Defined" Custom Column: "Developer-defined" means you make all the decisions — which is both the hardest and most flexible option. You choose the state schema, the checkpoint format, the retry policy, the event format, and the persistence backend. Frameworks give you primitives; the Custom column reminds you that even with primitives, you're still writing custom integration code.

How to Read the Table: Read row-by-row (by concern) when evaluating frameworks, not column-by-column. For each concern that matters to your application, compare how frameworks handle it. If you need protocol interoperability, read the Protocol Support row. If you need multi-agent coordination, read the Delegation row. If you need durable execution, read the Persistence row. The table is a decision aid, not a scorecard.

The "Custom" Column

Notice that "Custom" appears in every row. This is not a limitation of the comparison — it's a fundamental truth about agent harnesses.

Every harness is custom code. Even when you use a framework, you're writing custom tool definitions, custom routing logic, custom error handlers, custom state schemas, and custom persistence strategies. Frameworks shift where customization happens:

• With a managed cloud SDK (OpenAI Agents SDK): You configure agents, define tools, and set up handoffs. The SDK handles the inner loop, persistence, and streaming.
• With an enterprise SDK (MAF 1.0): You configure middleware, graph workflows, and protocol integrations. The framework handles session state and telemetry.
• With a graph runtime (LangGraph): You define the graph structure, node functions, and state schema. The runtime handles execution and checkpointing.
• With a protocol-native SDK (Google ADK): You define agents and tools, connect MCP servers and A2A peers. The framework handles discovery and routing.
• With a coding-agent runtime (Claude Agent SDK): You define tools and the agent loop. The runtime handles subagent spawning, permissions, and context compaction.
• With a multi-agent framework (CrewAI): You define agent roles, tasks, and delegation policies. The framework handles task routing and collaboration.
• With a TypeScript framework (Mastra): You define agents, workflows, and memory. The framework handles orchestration and observability.

The "Custom" column reminds you: frameworks don't eliminate decisions — they shift the abstraction level. You still choose how to model state, when to interrupt, what to persist, and how to recover from errors. The framework gives you primitives; you build the harness.

Ecosystem Evolution

The agent harness ecosystem has evolved through distinct phases, each adding new primitives:

Agent harness evolution timeline: raw API calls (2022) → thin SDKs (2023) → graph runtimes (2024) → durable orchestration (2025) → protocol-native runtimes (2026).

The timeline shows increasing abstraction:

1. Raw API Calls (2022): Developers called model APIs directly, executed tools in application code, and managed state manually. No harness frameworks existed.
2. Thin SDKs (2023): OpenAI introduced function calling schemas. SDKs wrapped the call-execute-return loop but left persistence and error recovery to developers.
3. Graph Runtimes (2024): LangGraph popularized explicit state graphs with checkpointers. Developers gained visual debugging and durable execution.
4. Durable Orchestration (2025): Temporal and Prefect integrations brought workflow-grade persistence and retry guarantees to LLM steps.
5. Protocol-Native Runtimes (2026): MCP (Model Context Protocol) enables dynamic tool discovery. A2A (Agent-to-Agent protocol) standardizes multi-agent communication. Harnesses become protocol-native.

2×2 matrix: runtime complexity (x-axis) vs multi-agent support (y-axis). Simple/single-agent: Claude Agent SDK, OpenAI Agents SDK. Middle: Mastra, Google ADK, LangGraph. Complex/multi-agent: MAF 1.0, CrewAI.

The matrix helps you choose: lightweight single-agent for prototypes and coding agents (Claude Agent SDK, OpenAI Agents SDK), mid-complexity for structured workflows (Mastra, Google ADK, LangGraph), enterprise multi-agent for production orchestration (MAF 1.0, CrewAI).

Trend Lines

Three trends are reshaping agent harnesses:

Convergence Toward Durable Execution

Early harnesses treated agent loops as ephemeral processes. State lived in memory; crashes lost work. Modern harnesses converge on durable execution:

• Checkpointing: LangGraph, Claude Agent SDK, and Temporal all provide checkpoint-based recovery.
• Exactly-Once Semantics: Temporal guarantees exactly-once execution for workflow activities.
• Replay Safety: Checkpointers enable deterministic replay from any saved state.

This trend is driven by production requirements: agents in customer-facing systems must survive restarts, network failures, and deployment rollouts without losing conversation state or re-executing expensive tool calls.

Framework examples:

• LangGraph added SQLite and Postgres checkpointers in 2024, enabling production-grade persistence beyond the original in-memory checkpointer.
• Claude Agent SDK has file-based checkpointing as a core primitive from its initial release, suited for local or self-hosted deployments.
• Temporal has always had durable execution as its foundational design — every workflow step is persisted and replay-safe by default.

Protocol-Native Tool Access (MCP)

Static tool registration hardcodes tool schemas at runtime startup. MCP (Model Context Protocol) enables dynamic tool discovery:

• Dynamic Discovery: Agents query available tools at runtime, adapting to new capabilities without redeployment.
• Standardized Context: MCP defines a protocol for exchanging context (e.g., file system access, database schemas) between agents and tools.
• Cross-Provider Compatibility: MCP is vendor-neutral, allowing agents to use tools from any MCP-compliant provider.

MCP shifts tools from "baked into the agent" to "discovered from the environment." This reduces coupling and enables runtime adaptability.

Framework examples:

• Claude products (Claude Desktop, Claude Code) were early MCP adopters, with native MCP support for dynamic tool discovery across desktop and CLI environments.
• Microsoft Agent Framework 1.0 ships with native MCP support as a first-class runtime primitive — agents can connect to any MCP server for tool discovery without custom adapter code.
• Google ADK connects agents to MCP servers alongside A2A, enabling combined tool discovery and agent coordination.
• LangGraph has community-maintained MCP tool adapters that wrap MCP servers as LangChain tools.
• OpenAI announced experimental function-calling-to-MCP bridge capabilities in early 2026, though this remains in preview.

Standardized Agent Interoperability (A2A)

Multi-agent systems have historically used framework-specific message formats. A2A (Agent-to-Agent protocol) standardizes cross-runtime agent communication:

• Message Format: A common schema for agent-to-agent messages, task delegation, status updates, and results.
• Handoff Protocol: Standard semantics for transferring control between agents across different runtimes.
• Discovery: Agents discover peers via registries, enabling decentralized multi-agent systems.
• Identity and Trust: Authentication and authorization for agent-to-agent communication.

A2A has gained significant traction. The Linux Foundation reported that A2A support grew to over 150 organizations in its first year, including AWS, Cisco, Google, IBM, Microsoft, Salesforce, SAP, and ServiceNow. Production deployments exist in Azure AI Foundry, Amazon Bedrock AgentCore, and Copilot Studio.

Framework examples:

• Microsoft Agent Framework 1.0 ships with native A2A support. Copilot Studio A2A reached general availability, meaning MAF SDK-built agents and Studio-built agents can communicate directly.
• Google ADK includes A2A codelabs showing ADK agents exposed as A2A services, with MCP integration alongside A2A for combined tool discovery and agent coordination.
• LangGraph and CrewAI communities have early A2A adapters for cross-framework agent communication.
• Full production A2A with identity verification, durable delivery, and error recovery is still maturing. Most deployments are within single-vendor ecosystems (Azure, Google Cloud), not truly cross-vendor federations.

Exercise: Match the Framework

For each scenario below, identify which harness category (Agent SDK, Graph Runtime, Workflow Runtime, or Multi-Agent Runtime) is the best starting point, and name a specific framework.

Scenario 1: You are building a chatbot that helps users navigate a documentation site. The agent needs to search docs, answer questions, and occasionally call a code execution tool. Sessions are short (under 5 minutes) and conversations are independent.

Scenario 2: You are building a content pipeline that receives user requests, assigns research to one agent, writing to another, and editing to a third. Each agent has a specialized system prompt and tools. The pipeline runs for 30+ minutes per request.

Scenario 3: You are building an order fulfillment agent that processes returns. It must check inventory, issue refunds (with human approval for amounts over $200), update the database, and send confirmation emails. If any step fails, prior steps must be rolled back.

Scenario 4: You are building a code review agent that reads a pull request, checks multiple files, runs static analysis, and generates a structured report. The agent's behavior branches based on the type of changes detected (new feature vs. bug fix vs. refactor).

Suggested answers:

Scenario 1: Lightweight SDK — specifically Claude Agent SDK or OpenAI Agents SDK. Short sessions, no persistence needed, simple tool integration. A graph runtime or enterprise framework would be over-engineering.

Scenario 2: Multi-agent framework — specifically CrewAI. Multiple specialized agents with delegation, role-based task assignment, and sequential handoffs. The pipeline benefits from explicit role definitions and task routing. MAF 1.0 would also work if you need A2A interoperability or enterprise features.

Scenario 3: Workflow runtime (Temporal) or enterprise SDK (MAF 1.0). Durable execution with exactly-once semantics, compensation logic for rollbacks, human approval as a workflow signal, and cross-service orchestration. A lightweight agent SDK cannot provide the transactional guarantees this use case demands.

Scenario 4: Graph runtime — specifically LangGraph. Conditional branching based on state (change type), checkpointing for long runs, and explicit state transitions. The graph structure makes the branching logic visible and debuggable.

Summary

You now have a map of the agent harness landscape:

• The Big Seven: Microsoft Agent Framework, LangGraph, OpenAI Agents SDK, Google ADK, Claude Agent SDK, CrewAI, Mastra — plus Custom as the fully flexible baseline.
• Related and adjacent: AG2/AutoGen lineage, Semantic Kernel, Vercel AI SDK, Temporal, Prefect/Airflow — important but not primary harness frameworks.
• Comparison table: Runtime model plus ten concerns across eight harnesses, showing where frameworks provide primitives and where you write custom code.
• The "Custom" column: Every harness is custom code; frameworks shift abstraction levels.
• Ecosystem evolution: Five phases from raw API calls to protocol-native runtimes.
• Trend lines: Durable execution, MCP for dynamic tools (production-adopted), A2A for agent interoperability (150+ organizations, early production).

Lesson 12 will give you a selection framework: how to choose a harness for your production requirements.