COMPEL Specialization — AITE-ATS: Agentic AI Systems Architect Expert Article 11 of 40
Thesis. Six frameworks dominate the agentic orchestration space as of 2025–2026. None is universally correct. None is universally wrong. The architect who picks a framework from marketing materials inherits that framework’s assumptions, failure modes, and exit cost, whether they intended to or not. This article compares six frameworks at equal depth, names the specific capabilities an architect should evaluate, and produces a decision framework the learner can apply to their own organization. It is deliberately technology-neutral per the COMPEL design-doc §16.4 requirement, and it gives every framework the same airtime.
The six frameworks
- LangGraph (LangChain AI, 2024–present). State-graph-first. First-class support for interrupts, checkpointing, streaming. Python-dominant with JS bindings. OSS core.
- CrewAI (CrewAI Inc, 2024–present). Role-based multi-agent collaboration. Tasks-and-crews vocabulary. Python-dominant. OSS core with commercial offerings.
- AutoGen (Microsoft Research, 2023–present; v0.4 in 2024). Conversational multi-agent programming. Agent-to-agent messaging as the primitive. Python + .NET. OSS.
- OpenAI Agents SDK (OpenAI, 2025). Production-framed agentic SDK with handoffs, guardrails, tracing built in. Python-first. OSS.
- Semantic Kernel (Microsoft, 2023–present). Multi-language (C#, Python, Java). Plugin + planner + process abstraction. Enterprise-oriented. OSS.
- LlamaIndex Agents (LlamaIndex, 2024–present). Agent capabilities layered on top of a mature data/retrieval framework. Python-first. OSS.
Six capabilities to evaluate
Every framework makes trade-offs across the same six axes. The architect rates each framework per axis for the specific workload.
Axis 1 — Control-flow model
How does the framework express agent loops and multi-agent coordination?
- LangGraph: explicit directed graph; nodes and edges are code.
- CrewAI: role + task + crew abstractions; sequential or hierarchical execution.
- AutoGen: conversational messages between named agents; group-chat manager.
- OpenAI Agents SDK: agent with tools + handoffs; thin coordination layer.
- Semantic Kernel: Process Framework for explicit workflows; planner for auto.
- LlamaIndex Agents: ReAct-style or planning agents; query engine composition.
For highly-regulated workloads the architect prefers explicit control flow (LangGraph, Semantic Kernel Process); for exploratory assistants, implicit/emergent coordination (AutoGen, CrewAI) fits better.
Axis 2 — Safety features
What safety primitives does the framework ship natively?
- LangGraph: interrupts, state checkpointing, clean resume, retries. No built-in content filters, no native PII redaction. Guardrails bolt on.
- CrewAI: task validation callbacks, output schemas, retry policies. No native guardrails.
- AutoGen: termination conditions, message filtering hooks. Extension libraries provide guardrails.
- OpenAI Agents SDK:
input_guardrails,output_guardrails, tracing, tripwires — safety is a first-class feature here. The strongest native safety story of the six. - Semantic Kernel: function filters, content safety integration with Azure AI Content Safety. Enterprise-oriented.
- LlamaIndex Agents: response validation, query pipelines with filters. No native guardrail abstraction equivalent to Agents SDK.
For regulated deployments the architect wants native safety; OpenAI Agents SDK and Semantic Kernel lead here; others require bolt-on.
Axis 3 — Observability integration
What traces does the framework emit and which backends does it integrate with?
- LangGraph: LangSmith is primary but OTel emission is supported; Langfuse/Arize integrations available.
- CrewAI: CrewAI+ (commercial) tracing; OTel integrations supported; Langfuse works.
- AutoGen: OTel support in v0.4; detailed message logs.
- OpenAI Agents SDK: native tracing with external export; OTel-compatible.
- Semantic Kernel: OTel-first in latest versions; Azure Monitor integration.
- LlamaIndex Agents: callback manager emits trace events; several backends supported (Arize, Langfuse, W&B).
All six can emit OTel; the difference is completeness and out-of-box integration. Semantic Kernel and OpenAI Agents SDK have the cleanest native OTel story.
Axis 4 — Production maturity
Is the framework hardened for production scale — concurrency, error handling, long-running workflows?
- LangGraph: checkpointing + async is robust; used in production at scale.
- CrewAI: growing production footprint; some gaps in long-running orchestration.
- AutoGen: v0.4 rewrite addressed earlier production concerns; maturing.
- OpenAI Agents SDK: young (2025) but built on OpenAI’s production infrastructure.
- Semantic Kernel: most mature enterprise story; strong Microsoft platform integration.
- LlamaIndex Agents: mature on the data side, growing on the agent side.
No framework lacks production references; the architect checks which ones match the target deployment’s scale and reliability expectations.
Axis 5 — Multi-language support
Does the framework support the languages the organization’s platform already runs on?
- LangGraph: Python-first, JS bindings; other languages absent.
- CrewAI: Python only.
- AutoGen: Python + .NET.
- OpenAI Agents SDK: Python; JS roadmap.
- Semantic Kernel: C#, Python, Java — the broadest coverage.
- LlamaIndex Agents: Python + TypeScript.
Enterprises with a .NET or Java platform standard should treat Semantic Kernel as a default candidate.
Axis 6 — Exit cost and lock-in
How hard is it to migrate away from this framework?
- LangGraph: graph spec is portable in concept but LangGraph-specific; migration means rewriting. Tool definitions are reusable; prompt chains less so.
- CrewAI: role/task abstractions don’t map cleanly to other frameworks; migration is lossy.
- AutoGen: message-passing pattern is common; less-structured migration.
- OpenAI Agents SDK: tool definitions portable; handoff semantics OpenAI-specific; guardrails reusable in concept.
- Semantic Kernel: plugin concept is portable; Process Framework is SK-specific.
- LlamaIndex Agents: query engine and tool definitions portable; agent loop less so.
The portable layer across all six is: tool definitions (especially if authored in MCP format), evaluation harnesses, and memory stores. The non-portable layer is the coordination abstraction. The architect minimizes lock-in by keeping tools and memory outside the framework and treating the framework as a swappable orchestrator.
Four frameworks in worked depth
Per COMPEL §16.4, four frameworks receive equal-depth coverage. The canonical worked example: a three-agent customer-support system (intake classifier + refund specialist + escalation manager), implemented in each of LangGraph, CrewAI, AutoGen, and OpenAI Agents SDK. Word-for-word parity is impossible, but the architect’s reading is that each framework solves the same problem with different abstractions.
LangGraph. A directed graph with three agent nodes, a classifier-to-specialist edge, a specialist-to-manager edge on escalation criteria, and interrupt nodes at refund-approval points. State is a shared TypedDict; checkpointing writes to Postgres.
CrewAI. Three Agent role definitions, a Crew with sequential or hierarchical process, tasks per agent, shared context via Task.context. Hierarchical mode introduces an implicit coordinator; sequential is more deterministic.
AutoGen. Three AssistantAgent participants in a GroupChat, a GroupChatManager selecting speakers, termination conditions when resolution reached. Explicit signatures for inter-agent messages add safety.
OpenAI Agents SDK. Three Agent definitions with tools, handoffs from classifier to specialist, from specialist to manager. Guardrails at the classifier; tracing emits spans through the handoff chain.
All four implementations produce a functional three-agent system. The LangGraph version is the most explicit; CrewAI is the most concise; AutoGen is the most conversational; Agents SDK is the safest by default.
Framework-selection scorecard
The architect applies a weighted scorecard to select for the organization’s context.
| Criterion | Weight | Notes |
|---|---|---|
| Platform language alignment | 20% | Organizational language standards |
| Safety primitives available | 20% | Native vs bolt-on |
| Observability maturity | 15% | OTel completeness + backend |
| Production scale evidence | 15% | Reference deployments at target scale |
| Control-flow fit to workload | 15% | Explicit vs emergent |
| Exit cost | 15% | Migration path realism |
A typical regulated-enterprise scorecard often surfaces Semantic Kernel or OpenAI Agents SDK at the top; a regulated Python shop with no existing framework investment often picks LangGraph; a quick-to-market SaaS prefers CrewAI or Agents SDK for ergonomics; a Microsoft-stack enterprise defaults to Semantic Kernel.
The architect’s hedges
Three architectural hedges minimize the damage if the chosen framework becomes the wrong framework.
Hedge 1 — Authoritative tool registry in MCP format. The tool definitions live in an MCP-backed registry (Article 5). Switching frameworks means wiring the registry to new framework calls, not re-authoring tools.
Hedge 2 — Evaluation harness independent of the framework. The harness (Article 17) treats the agent as a black box (input → output) plus a structured trace for deeper checks. Switching frameworks means pointing the harness at a new executable; the test cases and the pass/fail criteria do not change.
Hedge 3 — Platform-owned observability. Traces are emitted to platform-owned OTel collectors rather than framework-native cloud services. Switching frameworks means updating the emission library; the trace store and the dashboards do not change.
The elephant in the room — framework churn
The agentic framework space is young; breaking releases are common; some of the frameworks named above will be deprecated, merged, or rewritten before 2028. The architect plans for this:
- Track releases. The architect or a designated deputy reads the framework’s release notes and participates in the community. Surprises from a breaking release are more expensive than the attention.
- Pin versions. Production runs on pinned versions; upgrade is a planned rollout with a compatibility test battery, not an incidental pip upgrade.
- Keep a migration playbook. For each framework in use, the architect maintains a one-page migration playbook — what-to-change-if-we-switch — even if the switch is hypothetical. Writing it forces clarity on which design decisions are load-bearing.
Real-world anchor — LangGraph and LangChain production adoption
LangGraph’s production adoption (2024–2025) — documented in LangChain’s public case studies and user reports — illustrates the state-graph approach at scale. Teams running high-throughput regulated agentic workloads (financial services, healthcare back-office) have published deployment patterns using LangGraph’s interrupt + checkpoint + resume pattern as the HITL substrate. The lesson is that the explicit-graph model scales when the workload has identifiable decision points; it groans when the decision points are too many to enumerate. Source: langchain.com public case studies.
Real-world anchor — AutoGen multi-agent research and production posts
Microsoft Research’s AutoGen publications (2023–2024) and the v0.4 redesign announcements document the framework’s evolution from a research tool toward a production framework. The conversation-as-primitive pattern fits emergent coordination tasks (research, brainstorming) and struggles with strictly-bounded workflows. AutoGen’s production story is strongest in internal Microsoft deployments and in research-adjacent enterprise workloads. Source: microsoft.github.io/autogen.
Real-world anchor — OpenAI Agents SDK launch (2025)
OpenAI’s 2025 launch of the Agents SDK positioned native safety primitives — guardrails, tripwires, tracing — as production requirements rather than add-ons. The SDK’s bet is that the agentic layer should be thin and the safety layer should be thick; early adopter reports (mid-2025 community posts) suggest the pattern holds for single-digit-agent workflows and is still maturing for dozens-of-agents orchestration. Source: platform.openai.com/docs/agents.
Closing
Six frameworks, six capabilities, three hedges. The architect picks deliberately, documents the choice, and invests in the hedges that make the choice reversible. Article 12 takes up the failure modes that appear at the seams between agents regardless of framework.
Learning outcomes check
- Explain six orchestration-framework capabilities with their architectural implications.
- Classify four frameworks (LangGraph, CrewAI, AutoGen, OpenAI Agents SDK) against each capability, citing specific evidence.
- Evaluate a framework choice for lock-in and identify the three architectural hedges that minimize it.
- Design a framework-selection scorecard tuned for a given organization’s context (language, risk class, scale).
Cross-reference map
- Core Stream:
EATE-Level-3/M3.3-Art11-Enterprise-Agentic-AI-Platform-Strategy-and-Multi-Agent-Orchestration.md. - Sibling credential: AITM-AAG Article 11 (governance of framework choice); AITF-DDA Article 8 (data-science angle on framework pick).
- Forward reference: Articles 12 (coordination failures), 29 (multi-agent patterns), 39 (build vs buy).