Multi-agent systems, concepts & patterns | The Agent Factory Podcast

Episode summary (multi-agent systems, context engineering, and production patterns)

• Software 3.0 + LLMs as the “operating system”

  • The hosts reference a paradigm shift from:
    • Software 1.0: explicit coding/instructions
    • Software 2.0: training neural networks
    • Software 3.0: building systems by programming with natural-language prompts, where the LLM drives behavior and the system supplies goals/context rather than step-by-step instructions.

• Context engineering (reducing the context-window bottleneck)

  • The episode argues that the main limitation isn’t model “intelligence,” but managing the limited context window (compared to precious “RAM/CPU” workspace).
  • Context engineering is framed as: “getting the right information at the right time.”
  • Three core strategies:
    1. Isolation: send only relevant data/schema to each sub-agent to reduce noise.
       • Mentioned example: a LangGraph video showing this approach (linked in show notes).
    2. Persistence: retrieve and reuse relevant prior conversation “memories” using relevance + recency.
    3. Context compression: summarize/extract only key facts to shorten what downstream steps receive.

• News: Gemini CLI (terminal-focused dev tool)

  • Google’s Gemini CLI brings Gemini into the terminal.
  • Claimed capabilities:
    • understand/fix codebases
    • help with complex git commands
    • non-coding tasks like generating slide decks, organizing photos, even implementing tutorials.
  • Notes that it can connect to local tools and use MCP servers for extended capabilities.
  • Used as an example of a specialized agent.

• News: A2A (agent-to-agent protocol) standardized for interoperability

  • Agent-to-agent protocol donated to the Linux Foundation to create an open standard for agent communication across vendors/builders.
  • Mentions an A2A sample (Python + Java agents) and that agents interoperate via A2A, with MCP servers referenced for parts of the setup.
  • Introduces A2A Inspector:
    • web-based open-source debugging tool for A2A servers
    • helps developers inspect/debug what’s happening in agent-to-agent conversations.

---

Main technical topic: Multi-agent systems

• Why multi-agent beats single-agent for complex problems

  • Refers to a LangChain benchmark result:
    • as you add more tools/domains to a single agent, performance drops and agents get “overwhelmed”
    • multi-agent architectures remain more resilient under added complexity/tooling.

• When to use single-agent vs multi-agent

  • Single agent: best for a single task / single job (one LLM used for reasoning, planning, actions).
  • Move to multi-agent when the task requires multiple distinct skills/domains.
  • Rule-of-thumb: if a problem resembles “a team with specialists,” consider multi-agent.

• Multi-agent architectural patterns

  • The episode groups patterns into categories:

1) Supervisor patterns (hierarchical delegation)

• Supervisor / org-chart model

  • A coordinating “supervisor” delegates work to specialized worker agents.

• Router-supervisor pattern (dynamic sequencing)

  • Supervisor talks to workers one by one, passing intermediate info.
  • Sequence is not fixed; it adapts depending on conversation/context.
  • Example described:
    • Business analyst → Data engineer → BI engineer
    • If the user wants a different chart type later, the system routes directly to BI engineer to adjust output without re-running earlier steps.

• Parallel supervisor

  • Delegates tasks that can run simultaneously.
  • Example: market research where one agent pulls sales figures, another summarizes recent news/press, another analyzes public sentiment at the same time.
  • Tradeoff/challenge: supervisor may fail to keep sending critical context to other agents (“compartmentalization”), which ties back to context engineering.

2) Deterministic flows (explicit process)

• Sequential flow

  • Agents run in a predefined order like an assembly line.

• Circular flow

  • Enables iterative refinement: e.g., coder → tester → back to coder until tests pass.

3) Dynamic / swarm pattern

• Distinct from supervisor: framed as control vs collaboration

  • supervisor has a clear coordinator (more predictable but can bottleneck)
  • swarm is more flexible (another agent can jump in if one gets stuck)

• Tradeoffs:

  • potential chaos (compared to a group chat without an admin)
  • requires careful design to keep agents aligned and on track.

---

Tutorial-like guidance: Cloud debugging + observability for multi-agent supervisor systems

• Developer Q&A focus

  • Question: supervisor-pattern multi-agent works locally, but visibility into delegations/tools becomes hard when running in the cloud.

• Recommended solution: observability

  • Log and trace:
    • incoming tasks
    • how the LLM breaks tasks into subtasks
    • which worker agent each subtask goes to and why
    • supervisor’s explicit reasoning for choosing workers

• Tools mentioned for logging/tracing

  • Google Cloud services like Cloud Monitoring
  • OpenTelemetry
  • ADK framework-specific integrations

• Tracing explanation (cloud tracing concepts)

  • Trace = end-to-end flow / transaction (one overall request/interaction)
  • composed of spans = smaller sub-requests/subtasks, nested like “matryoshka dolls”

• Example shown

  • Google Cloud Trace Explorer view for an agent system (“troubleshooting agent” with coordinator delegating a “flight information” task to a flight info agent).

---

Main speakers/sources

• Speakers: Shador (Shi Lador) and Vlad Klesnikov
• Referenced sources/tools:
  • Andrej Karpathy (software 3.0 talk)
  • LangChain benchmark paper
  • Google (Gemini CLI, A2A protocol + inspector, Google Cloud tracing tools)
  • Linux Foundation (A2A adoption)
  • Red Hat (A2A sample context)
  • LangGraph (example video)
  • OpenTelemetry
  • ADK (mentioned integration)