ReferenceReference

🤖Agent Ecosystem Reference

Agent Ecosystem Reference

Last verified: October 2026. The tooling for building agents changes fast, and some well-known projects have been archived since this page was first written. Licenses and project status below come from each project’s GitHub repo.


Agent Frameworks (The Builders)

If you are writing code to construct an agent, you need a framework to handle tool calling loops, state persistence, and error correction.

The space has converged on two distinct approaches: deterministic graph-based orchestration (where you define the flow explicitly as a state machine) and role-based delegation (where you define personas and let the system coordinate task handoffs).

Framework Comparison

FrameworkLanguageLicenseBest forMaturity
LangGraphPython & JSMITStateful multi-step agents, HITL workflowsProduction
Microsoft Agent FrameworkPython & .NETMITMulti-agent workflows; the successor to AutoGenProduction
CrewAIPythonMITRole-based collaborative agentsGrowing
ADK (Google)Python, JS, Java & GoApache 2.0Google Cloud deploymentsGrowing
PydanticAIPythonMITType-safe structured output, FastAPI-styleGrowing
MastraTypeScriptApache 2.0 (code under ee/ directories has a separate license)TypeScript/serverless agent workflowsGrowing

AutoGen is archived. Microsoft no longer provides bug fixes, security fixes, or support for it, and its README points new users to Microsoft Agent Framework. Existing AutoGen projects still run, but start new work elsewhere.


Node-Based (Graph Orchestrators)

These frameworks treat agent workflows as explicit state machines. Good when you need to audit exactly what happened and replay or branch at any point.

  1. LangGraph (Python & JS): Stateful agent orchestration with checkpointing (persists state between steps), time-travel debugging (re-run from any prior state), and Human-in-The-Loop (HITL) pausing (agent stops and waits for a human decision before continuing). The go-to choice for production agents that need audit trails or approval gates.
  2. Google ADK (Python, JS, Java, Go): Google’s Agent Development Kit. Modular at the tool, memory, and runtime layers, with native deployment into the Google Cloud / Vertex AI Agent Engine Runtime ecosystem. Each component (tool registry, session store, executor) is swappable.

Autonomous / Role-Based

These frameworks focus on defining personas and letting the “crew” coordinate task delegation.

  1. CrewAI (Python): Good for rapid prototyping of multi-agent scenarios (“The Researcher talks to the Writer”). You define roles and goals; the framework handles delegation. Can get a working multi-agent prototype running in a few hours.
  2. Microsoft Agent Framework (Python, .NET): Microsoft’s successor to AutoGen. It supports sequential, concurrent, handoff, and group-collaboration patterns, with state, observability, and human-in-the-loop control, and works with providers including OpenAI, Azure OpenAI, and Microsoft Foundry.

Lightweight / Typed / Serverless

  1. PydanticAI (Python): Favored for smaller, reliable components. Native integration with Python’s validation library ensures LLM structured outputs are type-checked at runtime, which cuts down on silent failures when models return malformed JSON.
  2. Mastra (JS/TS): Built for full-stack TypeScript developers. Avoids the “Python-first” overhead and is designed specifically for serverless-compatible deployment (e.g. Vercel, Cloudflare Workers).

Multi-Agent Orchestration Patterns

Early agent work focused on single models doing everything. The current pattern is to split that work: a planner or coordinator model breaks down a task and routes subtasks to smaller, cheaper worker models. Each worker gets a narrow, well-defined input and returns a structured output. This reduces errors, cuts cost per run, and makes failures easier to isolate.

  • Ruflo (formerly Claude-Flow): An agent harness for running swarms of coding agents and coordinating them on a shared task.
  • Vibe Kanban: A board-based tool where you assign tickets to coding agents such as Claude Code or Codex and review the results.

Low-Code / No-Code Orchestrators

If you prefer visually connecting nodes rather than writing Python/TS:

  1. n8n: A workflow automation tool with built-in AI agent nodes, memory buffers, and tool calling. You can build an agent that reads emails, calls an LLM, and writes to a spreadsheet without writing code.
  2. Langflow: An open-source, Python-based drag-and-drop builder for RAG pipelines and agents (MIT license).
  3. Dify: A platform for building LLM workflows visually, with a cloud-hosted option and self-hosting available.

Flowise, an earlier open-source drag-and-drop option, was archived by its maintainers on August 13, 2026 and is read-only. Pick Langflow or Dify for new projects.


When NOT to Use a Framework

Frameworks add overhead. If your task is simple, that overhead is not worth it.

Use a framework when you need state management across multiple steps, HITL checkpoints, or parallel agents that each need their own context. These are cases where rolling your own loop gets messy fast.

Use direct tool calling (covered in Module 6) when you have one model, one task, and well-defined inputs and outputs. A single model calling a weather API or querying a database does not need LangGraph. Plain function calling works, and it is easier to debug.

The line is roughly: if you’d need to draw a flowchart with branches and error states to explain it, use a framework. If you can explain it in one sentence, don’t.


  • The concepts behind agent types and patterns are in Module 5.
  • For direct tool calling without a framework, see Module 6.