#multi-agents — Agentic AI

Multi-agents: planner, workers, verifier. A DAG that beats the monolithic agent.

What you'll play with

Welcome to #multi-agents. A monolithic agent (see #react-loop) is a LLM that loops on its own. Here you decompose: a Planner (indigo, on top) splits the goal; N specialized Workers (green, in the middle) run in parallel; a Verifier (gold, at the bottom) checks and aggregates. This pattern (AutoGen, CrewAI, LangGraph, Claude Sub-agents) beats the monolithic on long tasks, in both quality and time. On screen: the DAG at rest — three dim nodes, fan-out and fan-in edges as dashed grey lines.
Let's load a goal. Type /scenario article: the Planner receives 'Write a blog article about RLHF', and three Workers appear (researcher, writer, critic).
The Planner steps up. Type /plan: it pulses indigo, dispatches roles to the Workers (small pink dots streak along the edges) and hands off.
The Workers get to work. Type /step: the green spheres pulse blue (busy), in parallel by default — so at the same time, one tick for the three.
Another /step. The Workers finish (solid green = success) and their dots streak toward the Verifier (fan-in). The banner switches to VERIFICATION.
/step one last time. The Verifier accepts, the phase moves to AGGREGATION and then DONE (green banner). The final output is the assembled article.
Let's switch to a richer scenario. Type /scenario code-review: three new Workers appear (syntax, security, style) to audit a Python file.
Let's simulate a Verifier reject. Type /retry: on the next round the Verifier will reject the output, the red feedback edge will light up, and the Workers will loop back for iteration 2.
Your turn. Try: /run to play the whole retry through; /workers 5 then /strategy parallel then /run to see a massive fan-out (5 Workers in a single tick); /strategy sequential to measure the cost without parallelism; /inspect worker-2 to read an agent's output; /reset to start over. Next: the #planning-reflection channel (Premium) — the Planner becomes reflective — and #slash-commands (Premium) — how these patterns become shortcuts in Claude Code and Cursor.

Channel commands

/scenario <article|translation|code-review> — Loads a full scenario (goal + specialty pool).
/plan — The Planner splits the goal and assigns roles to the Workers.
/step — Advances one notch in the orchestration.
/run — Plays the whole orchestration through to done or failure.
/workers <n=2..5> — Changes the number of active Workers (2..5).
/strategy <parallel|sequential> — Simultaneous fan-out (parallel) or one after the other (sequential).
/retry — Forces the Verifier to reject on the next check (retry).
/inspect <id> — Shows an agent's last message (planner, worker-1..N, verifier).
/reset — Resets the DAG (article, 3 workers, parallel).

Glossary

multi-agents: Orchestration pattern where several LLMs (or several roles of a single LLM) cooperate on a complex task. Each agent has a role (planner, worker, verifier, critic…) and a specialty. On long tasks, a multi-agents DAG beats a monolithic agent in both quality and time.
planner: Agent at the top of the DAG that splits the goal into sub-tasks and assigns roles to the Workers. Does not do the work itself: it steers. Anthropic calls this pattern orchestrator-workers in Building effective agents (2024).
worker: Executor agent, single-minded: researcher, writer, tester, translator, security auditor… Receives a sub-task from the Planner and returns a partial deliverable. Can be a distinct LLM, the same LLM with a role prompt, or a plain deterministic function.
verifier: Agent at the bottom of the DAG that checks and aggregates the Workers' outputs. If it spots a defect (consistency, schema, tone) it sends a directive back to the Planner: that is the retry loop. A LLM Verifier is often a smaller and cheaper model than the Workers.
DAG: Directed graph with no cycle: nodes are the agents, edges are message exchanges. Being acyclic guarantees we can unroll it in a finite number of steps. A cycle (feedback / retry) is modeled as an extra iteration, not as a cyclic edge of the DAG.
fan-out / fan-in: Fan-out: one node (the Planner) sends a task to N nodes in parallel. Fan-in: N nodes converge their outputs onto one (the Verifier). This is the pattern that yields the time saving of multi-agents.
AutoGen: Microsoft framework (2023) that popularized multi-agent conversation: each agent has a role system prompt and they exchange messages until they converge. Often cited as the first mainstream multi-agent framework.
CrewAI: Python framework (2024) inspired by AutoGen but process-oriented: you define a Crew with roles (Researcher, Writer, Reviewer), tasks and a flow. Pragmatic approach, widely used in production.
LangGraph: LangChain library (2024) that explicitly models orchestration as a state graph. Well-suited to conditional workflows (retry, branching, human-in-the-loop). Used by many agent stacks in production.
Claude Sub-agents: Claude Code feature (Anthropic, 2024) that lets you define specialized sub-agents (test-runner, refactor, doc-writer…) invoked by the main agent through /agent. A direct application of the orchestrator-workers pattern.

Other channels in Agentic AI

#react-loop — An agent's ReAct loop: Thought → Action → Observation, live.
#tool-calling — Tool calling (function calling / MCP): the JSON that makes the LLM act.
#slash-commands — Slash commands, Claude Code / Cursor style: templates, arguments, chaining.
#context-memory — Context window and agent memory: count, truncate, summarize, index.
#planning-reflection — Planning, reflection and self-correction: from 60% to 90% success.
#multi-agents — Multi-agents: planner, workers, verifier. A DAG that beats the monolithic agent.