Multi-Agent Systems

Steps

1. Tool Use — Overview anthropic-platform beginner

   How Claude calls external tools and functions — the foundation for building agentic systems.

   Every agent framework is built on a tool-use loop where the model calls functions and acts on results. Understanding this core loop first makes all four frameworks in this path make sense — they differ in how they orchestrate it.

2. Function calling openai intermediate

   Learn how function calling enables large language models to connect to external data and systems.

   OpenAI calls this function calling while Anthropic calls it tool use, but the core pattern is identical. Pay attention to how the request format differs — compare OpenAI's tool_calls array with Anthropic's content blocks to understand the portability challenges you will face.

3. Agent SDK — Overview anthropic-platform intermediate

   Introduction to Anthropic's Agent SDK for building custom AI agents with tool use, MCP, and sub-agents.

   The Anthropic Agent SDK wraps the tool-use loop into a managed runtime. Compare this approach with OpenAI's Agents SDK — both solve the same orchestration problem but Anthropic uses delegation while OpenAI uses explicit handoff transfers.

4. Subagents anthropic-platform intermediate

   Subagents are Anthropic's answer to multi-agent orchestration — a coordinator delegates to specialized workers. Unlike OpenAI handoffs, control returns to the coordinator after delegation. This difference affects how you design agent hierarchies.

5. Agents openai-agents intermediate

   Configure agent instructions, tools, guardrails, memory, and streaming behavior.

   The OpenAI Agents SDK defines agents with instructions, tools, and guardrails. Compare the agent definition pattern with CrewAI's role/goal/backstory and Anthropic's AgentConfig to see how each framework conceptualizes what an agent is.

6. Handoffs openai-agents intermediate

   Delegate tasks between agents with intent classification, argument passing, and return values.

   Handoffs transfer control from one agent to another permanently within a conversation. This is fundamentally different from Anthropic's subagent delegation where control returns — understanding this distinction is key to choosing between the two SDKs.

7. Understanding A2A a2a intermediate

   In-depth protocol explanation

   A2A operates at a different layer than the agent SDKs — it enables agents from different platforms to discover and communicate with each other. Think of it as the HTTP of multi-agent systems: a protocol, not a framework.

8. Crews crewai intermediate

   Understanding and utilizing crews in the crewAI framework with comprehensive attributes and functionalities.

   CrewAI organizes agents into crews with shared goals, which is a higher-level abstraction than individual agent orchestration. Compare the crew metaphor with LangGraph's explicit graphs — crews are more opinionated but require less architectural thinking.

9. Agents crewai intermediate

   Detailed guide on creating and managing agents within the CrewAI framework.

   CrewAI defines agents by role, goal, and backstory — a persona-based approach that differs from OpenAI's instruction-based and Anthropic's config-based definitions. The backstory concept is unique to CrewAI and influences how the agent approaches tasks.

10. Tasks crewai intermediate

    Detailed guide on managing and creating tasks within the CrewAI framework.

    Tasks in CrewAI represent work units assigned to agents with explicit dependencies. This is more structured than the freeform delegation in Anthropic's SDK — compare the tradeoff between declarative task graphs and imperative agent orchestration.

11. Thinking in LangGraph langchain intermediate

    Learn how to think about building agents with LangGraph

    LangGraph models agents as state machines with explicit nodes and edges. This graph-based approach gives you the most architectural control of any framework in this path, but requires you to design the state schema and transitions yourself.

12. Handoffs langchain intermediate

    LangGraph's handoff pattern lets agents transfer control along graph edges. Compare this with OpenAI's one-directional handoffs and Anthropic's bidirectional subagent delegation — LangGraph gives you the most flexibility since you define the graph topology.

13. Workflow Agents

    Google ADK introduces workflow agents — deterministic orchestrators that follow sequential, parallel, or loop patterns without using an LLM for routing. This is the counter-argument to LLM-driven coordination: sometimes a for-loop is the right abstraction. Compare with LangGraph's graph-based approach.

14. Multi Agents

    ADK's multi-agent systems combine LLM agents (reasoning-driven decisions) with workflow agents (deterministic control flow). The key insight: use LLM agents only for decisions that require reasoning, and workflow agents for everything else. Compare this composition model with CrewAI's flat crew structure.

15. Agent Framework Overview ms-agent-framework intermediate

    Introduction to Microsoft Agent Framework: combining AutoGen's agent abstractions with Semantic Kernel's enterprise features for production-grade multi-agent orchestration.

    Microsoft Agent Framework is the production-grade successor to AutoGen, combining its multi-agent abstractions with Semantic Kernel's enterprise features. If you're evaluating frameworks for enterprise deployment, this is the Microsoft-backed option with Azure integrations, persistence, and telemetry built in.

16. Workflows Overview ms-agent-framework intermediate

    Graph-based workflow orchestration: defining agents as nodes, transitions as edges, and execution strategies (sequential, parallel, conditional).

    Agent Framework's graph-based workflows define agents as nodes and transitions as edges with explicit execution strategies (sequential, parallel, conditional). Compare with LangGraph's state machines — both use graphs, but Agent Framework emphasizes enterprise patterns like middleware and durable execution.

17. GroupChat Pattern autogen intermediate

    AutoGen's GroupChat coordinates multiple agents through managed conversation turns with configurable speaker selection strategies (round-robin, LLM-driven, or custom).

    AutoGen's GroupChat is the most conversational orchestration pattern — agents take turns in a shared chat, with a manager selecting the next speaker. This is historically important: it influenced how later frameworks think about multi-agent coordination. Compare with CrewAI's hierarchical process which also uses a manager agent.

18. Symphony Overview openai-symphony intermediate

    Symphony turns project work into isolated, autonomous implementation runs. It polls issue trackers, spawns coding agents per issue in isolated workspaces, and manages the full lifecycle from ticket to merged PR.

    Symphony operates at a completely different level than every other framework in this path. Instead of orchestrating tool calls within a conversation, it orchestrates entire development workflows: polling an issue tracker, spawning isolated coding agents per issue, and requiring proof-of-work before code lands. Study this to understand where the orchestration landscape is heading.