Appendix A: Agentic Frameworks Survey — April 2026#
This survey covers the major open-source and commercial agentic frameworks as of April 2026. For each framework we note: maturity, topology support, HITL, memory, MCP support, Python-native status, and guidance on when to choose it over building from scratch.
The goal is not to recommend one framework. The goal is to help you decide when reaching for a framework is the right call — and when building the primitive yourself is better.
Framework Comparison Table#
| Framework | Maturity | Topology | HITL | Memory | MCP | Python-native | Best For |
|---|---|---|---|---|---|---|---|
| LangGraph | Production | DAG + cycles | Built-in checkpointing | External (LangSmith) | Via tools | Yes | Stateful multi-step workflows with complex branching |
| CrewAI | Production | Role-based crews | Limited | Role context | Partial | Yes | Task delegation to specialised role agents |
| OpenAI Agents SDK | Production | Linear + handoffs | Guardrails API | Threads API | Yes (native) | Yes | OpenAI-first stacks with native tool/handoff support |
| Google ADK | Beta | Multi-agent + A2A | Session state | Vertex Memory | A2A native | Yes | Google Cloud stacks; A2A-first interop |
| AutoGen / AG2 | Production | Conversational + group | Human proxy agent | Plugin | Via tools | Yes | Research prototyping; conversation-centric pipelines |
| Swarms (kyegomez) | Early prod | Hierarchical + sequential | Limited | SQLite/Redis | Partial | Yes | Large-scale swarm experiments; rapid prototyping |
| Agno | Beta | Pipeline + parallel | Webhooks | Built-in | Partial | Yes | Structured pipeline workflows; observability-first |
Per-Framework Notes#
LangGraph is the most mature framework for stateful agentic graphs. Its persistence model (checkpointing via LangSmith or custom backends) is well-suited for long-running workflows. The DAG-with-cycles model maps naturally to the orchestrator-worker patterns in Module 8. Downside: the abstraction layer is thick — debugging requires understanding LangGraph internals on top of your own logic.
CrewAI makes role-based multi-agent patterns easy to express. If your problem decomposes naturally into a "crew" of specialists (a researcher, a writer, an editor), CrewAI handles the delegation boilerplate. Downside: the role abstraction can become a straitjacket when your topology doesn't fit a crew model.
OpenAI Agents SDK is the most polished production SDK as of April 2026 for OpenAI-native stacks. Native MCP support, Responses API integration, and the Guardrails API for HITL make it a strong choice if you're all-in on OpenAI. Downside: tightly coupled to OpenAI — multi-provider support requires wrapping.
Google ADK is the natural choice for Vertex AI and Google Cloud environments. Its native support for A2A (Agent-to-Agent protocol) makes it interesting for heterogeneous multi-framework swarms. Still in beta as of April 2026.
AutoGen / AG2 excels at research prototyping where you want to experiment with conversation patterns quickly. The human proxy agent is one of the cleanest HITL implementations in any framework. Downside: the conversational abstraction becomes limiting in structured orchestration scenarios.
Swarms (kyegomez) is best for experiments at scale — running 50+ agents in parallel topologies. The API is less polished, but the breadth of supported topologies is impressive. Use it when you're exploring, not when you're shipping.
Agno is worth watching. Its observability-first design (every agent run is traced by default) aligns well with the patterns in Module 7. Still maturing.
When to Build from Scratch#
Build from scratch when: - You need tight control over cost (most frameworks make it easy to overspend) - You have unusual topology requirements that don't fit any framework's model - You are in a regulated environment where every component must be auditable - You are learning (the entire premise of this course)
Use a framework when: - You need to ship a product quickly and the framework's topology fits your problem - Your team includes people unfamiliar with agent primitives (framework scaffolding helps) - The framework's observability tooling (LangSmith, etc.) provides genuine value
The patterns in this course — once you have built them — translate directly to any of the frameworks above. Understanding what fork-join means from first principles makes you a better LangGraph user, not worse.