“multi-agent”
Microsoft Agent Framework: Multi-Agent Patterns with Azure AI Foundry
Multi-agent patterns in the Microsoft Agent Framework — orchestrator-worker, sequential and concurrent handoffs, shared blackboard state and A2A — wired into Azure AI Foundry for deployment, RBAC, tracing and evaluation.
Routing Tasks Across Agents with the A2A Protocol
Build a router that matches incoming work to the right remote agent with A2A: skill-based routing from Agent Cards, task delegation patterns, fan-out and fallback, and a working Python router over JSON-RPC.
Cross-Organization Collaboration: A2A in Multi-Vendor Stacks
How independent organizations run Agent2Agent (A2A) collaborations across vendor boundaries: opaque agents, signed Agent Cards, cross-org discovery, contractual delegation, and the governance patterns that keep multi-vendor agent stacks operable.
Building an Agent Swarm with Google ADK: Multi-Agent Systems Done Right
Learn how to build an agent swarm or multi-agent system with Google's Agent Development Kit (ADK) using deterministic workflow wrappers, shared session scratchpads, and Agent-to-Agent (A2A) RPC calls.
Nami Mini: A Single-Binary AI Agent Framework Built in Rust
A deep dive into nami-core-mini — an advanced AI assistant and autonomous agent framework written in Rust, powered by adk-rust and Google Gemini, with hierarchical multi-agent delegation, MCP, SQLite memory, and a multimodal media pipeline.
Deep Delegation Chains: Hierarchies That Stay Reliable
How to build multi-level agent hierarchies that don't collapse under their own complexity — context isolation, bounded delegation depth, and the deep-agents approach to long-horizon work.
Automating Tax Preparation Workflows with Specialized Multi-Agent Fleets
Multi-agent tax document ingestion (W-2, 1099, 1098), calculation agents, compliance checkers, and audit log generation using Gemini 3 & Pydantic AI.
Leader-Agent Orchestration: Coordinating Specialist Sub-Agents in LangGraph
Build the leader (supervisor) pattern as an explicit LangGraph state machine: graph structure, routing, shared vs private state, failure handling and hard stopping conditions for delegated sub-agents.
Google ADK Workflows: From ReAct Loops to Graph Execution
How one ADK agent's think-act-observe loop generalizes into Sequential, Parallel and Loop agents, session state, and ADK 2.0 graph workflows.
Delegated Authorities: Scoped Permissions for Sub-Agent Execution
Give sub-agents only the authority their task requires: why tool lists are not permissions, how agents-as-tools and handoffs differ in privilege, building a delegation layer with capability objects, and enforcing scope at the runner rather than trusting the prompt.
Correlation IDs Across Agent Handoffs
Keep a single identifier alive as control moves between agents: why log IDs break at handoffs, how OpenTelemetry context propagation and baggage carry correlation across boundaries, the security rules for propagating IDs, and a concrete schema for multi-agent trace correlation.
CrewAI in Depth: Roles, Tasks, and Process Orchestration
A practical tour of CrewAI's core abstractions — agents, tasks, processes, and Flows — with guidance on when this role-shaped framework beats a graph-based one.
Moving Beyond Monolithic Prompts: A Guide to Graph Engineering with ADK
Learn how graph engineering with Google ADK breaks down complex AI workflows into testable, production-ready systems using nodes, edges, and powerful design patterns.
Sharing State Across Agent Boundaries: Context Contracts
Define type-safe context contracts with PydanticAI to share validated state safely across multi-agent handoffs and boundary transitions.
Orchestrator-Worker Decomposition: Splitting Complex Tasks Across Agents
Decompose complex multi-step goals into structured worker sub-tasks using the Google Agent Development Kit (ADK) Orchestrator-Worker pattern.
Fan-Out/Fan-In: Parallel Execution in Multi-Agent Systems
Master the Fan-Out/Fan-In orchestration pattern in LangGraph to run concurrent worker agents in parallel and aggregate multi-agent insights.
Handoff Design: Passing State and Control Between Agents
A deep dive into agent handoff patterns — how to pass state and control between agents cleanly, with SDK implementations and failure mode analysis.
Agent Discovery with A2A: How Peers Find Each Other
Implement agent discovery using the A2A protocol. Let agents publish capabilities, discover peers, and collaborate across organizations.
Distributed Tracing for Multi-Agent Systems
Implement distributed tracing for multi-agent systems using OpenTelemetry. Track tool calls, reasoning chains, and inter-agent communication across your fleet.
The Supervisor Pattern: Coordinating Specialist Agents in LangGraph
Implement the supervisor pattern in LangGraph to coordinate specialist agents. Build a routing system that delegates tasks to expert sub-agents and aggregates results.
Checkpointing Agent State with LangGraph: Threads, Checkpointers, and Resume
Master LangGraph checkpointing to persist agent state, resume interrupted workflows, and build fault-tolerant multi-step agent systems with threads and checkpointers.
Model Routing for Multi-Agent Systems: Matching Tasks to the Right Model
Learn how to implement intelligent model routing in multi-agent systems using LiteLLM, matching each task to the optimal model for cost, speed, and quality.
Agents as Tools: Composing Hierarchical Agent Networks
Master the agents-as-tools pattern for building hierarchical multi-agent systems using the OpenAI Agents SDK for complex orchestration workflows.
Graph-Based Orchestration: Sequential, Parallel, and Handoff Patterns
Master graph-based orchestration patterns for multi-agent systems with LangGraph, including sequential processing, parallel execution, and agent handoff mechanisms.
Demystifying Graph Engineering in the Age of AI Agents
An overview of graph engineering for AI agents, covering harness, loop, and graph concepts, why it differs from knowledge graphs, and how fan-out, join, and router nodes power reliable agentic workflows.
A2A Protocol in Practice: Cross-Organization Agent Collaboration
Connect agents built on different frameworks and owned by different teams with the Agent2Agent protocol. Learn Agent Cards, discovery, delegation, and secure cross-org collaboration.
The OpenAI Agents SDK: From Single Agent to Delegation at Scale
Learn the two core multi-agent patterns in the OpenAI Agents SDK—handoffs and agents as tools—and how to scale from a single agent to a delegating fleet of specialists.
Building Enterprise-Grade Multi-Agent Systems with the Microsoft Agent Framework
Take multi-agent systems from prototype to production with Microsoft Agent Framework 1.0. Learn graph-based orchestration patterns, checkpointing, human-in-the-loop, and deploying to Foundry Hosted Agents.
Running Gemma 4 On-Device in a Multi-Agent Flutter App
Lessons learned running Gemma 4 E4B inside a Flutter app with multi-agent concurrency. Learn the platform channel bridge pattern, engine singleton design, serialization, and the multimodal constraints that bite in production.
Building a Multi-Agent System with Google ADK
Move from single-prompt chatbots to a team of collaborating agents. Use Google ADK hierarchy, workflow agents, and session state to orchestrate a research-and-write pipeline.
Top AI Agent Frameworks for 2026: A Practical Comparison
A practical, evidence-based comparison of the leading AI agent frameworks in 2026 — LangGraph, CrewAI, OpenAI Agents SDK, AutoGen/AG2, Google ADK, and more — with guidance on how to choose.
The "Persona-Shift" Pattern: Dynamic Expert Simulation in Gemini 3
A static persona limits an agent to one role. Learn the Persona-Shift pattern: dynamic expert switching in Gemini 3 agents that lets a single model act as planner, critic, and specialist across a workflow — without persona drift.
Building a Meta-Agent: The Gemini 3 Orchestrator of Orchestrators
A meta-agent is a higher-order agent that operates on other agents. Learn the orchestrator-of-orchestrators pattern: hierarchical planning, sub-agent split, lazy tool discovery, and Git-like execution traces.
Securing Agent Communications: Encryption Strategies for the Gemini 3 Mesh
Agent-to-agent communication is the new attack surface. Learn encryption strategies for the Gemini 3 mesh: AgentCards, mTLS, E2E payload encryption, and replay protection.
The Sub-Agent Pattern: Delegating to Specialized Gemini 3 Workers
Single-LLM workflows suffer context saturation. Learn the sub-agent pattern: coordinator plus specialized Gemini 3 workers with scoped context, routing, and model tiering.
Maker-Checker & Multi-Agent Orchestration Patterns
Learn advanced multi-agent patterns including Maker/Checker separation, fan-out/fan-in sub-agent orchestration, background scheduled loops, and autonomous goal-seeking systems.
Secure Agent Gateways: Managing Auth for Gemini 3 Multi-Agent Systems
A deep dive into building secure gateways for multi-agent clusters using Gemini 3 and the Agentic Development Kit (ADK).
Multi-Agent Systems with ADK-Rust: Orchestration and Delegation
Explore how to build complex multi-agent systems in Rust using ADK, from simple delegation to sophisticated graph-based orchestration.