History Problem Orchestrator Team Stagnation Results Impact Deep Dive Quiz
Interactive Paper Explainer

One Conductor, Many Players
Magentic-One

A visual, step-by-step guide to the paper that introduced Magentic-One — Microsoft's open-source generalist multi-agent system, in which a lead Orchestrator plans, tracks progress, and re-plans while directing a team of web, file, and code specialists.

Start Learning Read the Paper ↗
1
Orchestrator (lead agent)
2
Nested Loops (plan · execute)
4
Specialist Agents
3
Benchmarks, One Config
History

From Solo Agents to Orchestrated Teams

Magentic-One arrived after two years of rapid experimentation: first single agents with tools, then role-playing agent societies, then benchmarks that punished both. Here is the road.

2022–23
Single agents learn to act
ReAct interleaves thought–action–observation and Toolformer teaches models to call tools — one brain, one loop, one narrow skill at a time.
2023
Teams of agents emerge
CAMEL and MetaGPT cast LLMs in human roles (researcher, engineer, reviewer) and let them talk; Microsoft's AutoGen generalizes multi-agent programming.
2023–24
Benchmarks demand breadth
GAIA, WebArena, and AssistantBench mix web browsing, file handling, and coding inside single tasks — a specialist that wins one benchmark fails the others.
2024 · Nov
🚀 Magentic-One
One open-source system: an Orchestrator with two ledgers and two loops, directing WebSurfer, FileSurfer, Coder, and ComputerTerminal — the same team on every benchmark.
2024–25
Orchestrators go mainstream
The system is open-sourced on AutoGen (aka.ms/magentic-one) with AutoGenBench; plan–track–re-plan orchestrator teams spread across agent frameworks.
Next
Agent teams as infrastructure
Plug-and-play specialists, cheaper models per role, and humans-in-the-loop oversight — the paper's own roadmap for generalist agent teams.
Key Insight

Complex tasks need management, not just talent. The bottleneck is rarely one missing skill — it is knowing what to do next, noticing that you are stuck, and changing course. Magentic-One makes one agent, the Orchestrator, responsible for that meta-work, so every specialist can stay simple.

THE ORCHESTRATION CYCLE
plan → dispatch → observe → track → stalled? → (re)plan
One loop to plan the work, one loop to work the plan.
Chapter 01

Why Generalists Are Hard to Build

Before Magentic-One, agentic systems faced a fork: be a specialist that wins one benchmark, or a solo generalist that drowns in its own task. The paper's goal: one high-performing system across many task types.

🕸️
The Specialist / Soloist Trap
  • One system per benchmark: web agents, file agents, code agents — each re-engineered for its own arena
  • Solo agents drown in long tasks: dozens of tools in one prompt, no working memory of "where am I?"
  • Rigid workflows: adding a skill means re-prompting or re-training the whole system
  • Errors are fatal: one wrong click or bad script ends the run — there is no notion of "we're stuck, change course"
  • Stateful environments punish evaluation too: agents leave side effects that corrupt later runs
🎼
Magentic-One's Answer
  • One team for many tasks: web + files + code composed on the fly by a lead agent
  • Two ledgers give working memory: a task ledger (plan + facts) and a progress ledger (state + next step)
  • Plug-and-play modularity: agents can be added or removed with no re-prompting of teammates
  • Stalls are detected and plans revised — errors become recoverable, not fatal
  • AutoGenBench runs each task in a fresh Docker container, so evaluation stays clean
The Analogy — A Project Manager with a Small Skilled Team

Think of Magentic-One as a project manager leading four specialists. The PM writes the plan and the checklist (task ledger), runs a stand-up every cycle to ask "done? blocked? who's next?" (progress ledger), and re-plans when the team stalls. The PM never touches the keyboard — the web researcher drives the browser, the analyst writes the code, and ops runs it. The paper uses its own analogy for the WebSurfer: telephone tech support — the Orchestrator knows what to do but cannot act, so it relays instructions and reads back the reports.

ORCHESTRATOR "WebSurfer — find the three cheapest 2024 electric SUVs and save the source URLs."
WEBSURFER "Found 3 models. Screenshot + page summary attached. Sources: siteA.com, siteB.com, siteC.com."
ORCHESTRATOR "Progress ledger: forward. Coder — build a comparison table from those sources."
Chapter 02

The Orchestrator — Two Loops, Two Ledgers

Magentic-One's core contribution is not a new model — it is a control system. A lead agent runs two nested loops, one for planning and one for execution, and keeps everything it knows in two structured ledgers.

The Lead Agent
🧠
Plans
Writes a step-by-step natural-language plan, assigned to agents.
📍
Tracks
Checks progress every cycle: done? looping? moving forward?
🔁
Re-plans
Breaks out, reflects, and rewrites the plan when the team stalls.
📤
Dispatches
Picks the next agent and gives it an explicit instruction.
🏁
Decides
Stops on completion, max attempts, or a time limit — then reports.

In the paper's default configuration the Orchestrator uses GPT-4o; a stronger variant swaps in OpenAI o1-preview for the outer loop. It never acts directly — it only directs.

Task Ledger = { facts: given ∪ to_look_up ∪ to_derive, guesses, plan }
GIVEN
Verified facts
Stated in the request, or already confirmed during the task.
LOOK UP
Facts to find
To be retrieved, e.g. via web search with the WebSurfer.
DERIVE
Facts to compute
To be calculated programmatically or by reasoning.
GUESSES
Educated guesses
Qualified closed-book guesses — a guarded fallback when agents are stuck or out of time.
PLAN
Steps → agents
A chain-of-thought-style hint in natural language, one entry per step with its assigned agent.

The task ledger is the outer loop's short-term memory. After every plan update, all agents clear their contexts and reset — the new plan is the single source of truth.

Outer Loop — Planning

Triggered by the task itself. The Orchestrator reflects on the request, pre-populates the task ledger (facts, facts to look up, facts to derive, guesses), considers its team's descriptions, and writes the plan. The loop re-runs whenever the inner loop gives up — each time with a reflection on what went wrong. Output: a fresh task ledger and plan.

Inner Loop — Execution

Runs every cycle of actual work. Each iteration, the Orchestrator answers five questions into the progress ledger: Is the task complete? Is the team looping? Is forward progress being made? Which agent should speak next? What instruction should it get? Then it dispatches that agent and watches what happens.

Interactive Demo — Loop Lens

Toggle between the two loops. The outer loop is a one-pass pipeline from goal to plan; the inner loop is a ring the team spins in until the progress ledger says stop.

Interactive Demo — The Orchestrator Console (Centerpiece)

A scripted orchestration run, one step at a time. Watch the task ledger fill in during outer-loop steps, the progress ledger update during inner-loop steps, and the dispatch row flash the chosen agent. Mid-run, the team hits a stall — and the console re-plans.

MISSION: "Compare 2024 electric SUV prices and write a summary with sources."
TASK LEDGER · outer loop
PLAN
PROGRESS LEDGER · inner loop

Scripted illustration of the paper's mechanism. The FileSurfer stays idle here — not every task needs every agent; in the paper's ablations, removing it still costs up to 39% on GAIA.

Chapter 03

The Team — Four Specialists

Magentic-One's agents are tool-centric, not role-centric: instead of "researcher" or "critic", each agent owns one capability — the browser, the files, the code, the console. This is the paper's recipe for clean separation of concerns and reuse.

🌐 WEBSURFER
Browser
LLM-based, multimodal · commands a Chromium browser and reports the page state
📂 FILESURFER
Files
LLM-based · reads PDFs, Office docs, images, audio, video via a read-only markdown preview
⌨️ CODER
Code
LLM-based · writes programs, analyzes findings, debugs from console output
🖥️ COMPUTER TERMINAL
Console
Deterministic, no LLM · executes Python and shell, installs libraries
Interactive Demo — Team Roster

Click a specialist to see its tools, an example action, and when the Orchestrator calls it.

WHO HANDLES WHAT
A Hierarchy of Tool Use

Instead of choosing between dozens of raw actions, the Orchestrator only picks which agent provides a broad capability (e.g. browsing). The chosen agent then selects among its own small action set — click versus scroll, say. Two small decisions replace one giant one, which the authors argue is easier for LLMs to reason about.

Mixed Models, One Team

Modularity lets each role use the model that fits: multimodal GPT-4o for web and file surfing, optionally the stronger reasoning model o1-preview for the Orchestrator's outer loop and the Coder, and no LLM at all for the terminal. The paper points to cheaper, smaller models per subtask as a cost-reduction path.

Chapter 04

Detecting the Stall

Agents fail in a particularly human way: they repeat the same failing action over and over. Magentic-One's answer is a counter, a budget, and a willingness to throw the plan away.

if stall_counter > 2 → break inner loop → reflect → revise plan → restart
COUNTER
Watch the loop
Every inner-loop cycle, the Orchestrator checks: is the team looping or making no forward progress? If so, the counter ticks up.
≤ 2
Recovery budget
While the counter stays at or below the threshold, the Orchestrator keeps dispatching — small errors get a chance to self-correct.
BREAK
Leave the inner loop
Once the budget is exceeded, execution stops. No more blind retries.
REFLECT
Self-refinement
A new outer-loop pass asks: what went wrong, what did we learn, what would we do differently?
REVISE
New task ledger
The task ledger is updated, the plan rewritten, agent contexts cleared, and the inner loop restarts.
STEP 1 · WATCH
Each cycle, the progress ledger answers five questions — including "is the team looping?" and "is forward progress being made?"
STEP 2 · COUNT
A repeated action or a stalled state increments the stagnation counter. Two identical failed scrapes? That's a loop.
STEP 3 · BUDGET
While the counter is within budget (≤ 2 in the paper's experiments), the team keeps its head down and keeps trying.
STEP 4 · RE-PLAN
Budget exceeded → break, reflect, update the task ledger, rewrite the plan, reset agents, spin the inner loop again.
STEP 5 · TERMINATE
If re-plans run out — a configurable maximum attempt count or time limit — the loops end and the transcript is reviewed.
STEP 6 · REPORT
On termination the Orchestrator reviews the full transcript plus ledgers, then reports the final answer — or its best educated guess.
Why This Matters

The counter gives agents a limited budget to recover from small errors while guaranteeing they cannot spin forever — and the re-plan means the system's response to failure is a new strategy, not louder repetition. In the paper's own error analysis, the top failure code is exactly the disease this treats: persistent-inefficient-actions — agents repeating unproductive behaviors without adapting. The stagnation mechanism is the cure, applied at the team level.

Chapter 05

One Config, Three Benchmarks

The same unmodified team — same agents, same collaboration, same prompts — ran on GAIA, AssistantBench, and WebArena. The result: statistically competitive performance with the state of the art.

Test-Set Results — Task Completion Rate % (Table 1 of the paper)
System (model)GAIAAssistantBench (EM)AssistantBench (acc)WebArena
GPT-4 (no agent team)6.676.116.514.9
Magentic-One (GPT-4o)32.3311.025.332.8
Magentic-One (GPT-4o + o1-preview)38.0013.327.7—*
Best single-benchmark baseline (Oct 2024)40.53 (omne v0.1)13.8 (SPA→CB, Claude)26.437.2 (WebPilot)
Human92.0——78.2

* o1-preview refused parts of WebArena (26% of Gitlab tasks), so that cell is not reported. Baselines differ per column — among Table 1's baselines, no prior system (other than base models) had been evaluated across all three benchmarks. Magentic-One (GPT-4o, o1) is statistically comparable to SOTA on GAIA and AssistantBench; on WebArena, the GPT-4o variant is comparable to most SOTA methods except WebPilot and Jace.AI.

GAIA · TEST SET
38.0
% vs 92.0 human — statistically comparable to SOTA
GPT-4o + o1-preview · 300 hidden questions
ASSISTANTBENCH · ACC
27.7
% accuracy (13.3 EM) — comparable to SOTA
181 hidden questions · real websites
WEBARENA · ALL 812
32.8
% (GPT-4o config) — comparable to most SOTA
5 synthetic websites + cross-site tasks
MODELS SWAPPED, TEAM UNCHANGED
0
changes to agent capabilities or collaboration across benchmarks
Only a final formatting prompt differed
Ablations — Every Piece Pulls Its Weight (GAIA validation set)

Replacing the Orchestrator with a simple group-chat manager — no ledgers, no planning, no loop detection — drops performance by ~31%. Removing any single specialist costs between ~21% (Coder, ComputerTerminal) and ~39% (FileSurfer). The team even compensates creatively: with no Coder, agents once had the FileSurfer read code and reason out the answer.

What Magentic-One Did NOT Solve
Legacy

Impact — Orchestration as a Pattern

Magentic-One distilled "how should a generalist agent team be run?" into a reusable architecture. Its ideas outlived its benchmark numbers.

📦 Open-source release
The full system shipped on Microsoft's AutoGen framework (aka.ms/magentic-one) — a rare open, reproducible generalist agent at the time.
🧠 The orchestrator pattern
Plan → dispatch → track → re-plan became a reference architecture for lead-agent designs across later agent frameworks.
🧩 Generalist over specialist
One unchanged team, three benchmarks, statistically competitive — evidence that breadth comes from composition, not from one giant prompt.
📒 Ledgers as a design idea
Explicit checklists for "what do I know" (task ledger) and "where am I" (progress ledger) — short-term memory as an engineering artifact, not a hidden state.
🛡️ Safety spotlight
The paper documents real near-misses — locked accounts, agents trying to recruit humans — arguing for least privilege and maximum human oversight.
📏 Rigorous agent evaluation
AutoGenBench: fresh Docker containers per task, repetition for stochastic variance, and isolation from side effects — now a template for agentic evals.
Deep Dive

The Orchestrator's Two Ledgers

Magentic-One's architecture is a loop with bookkeeping. An outer loop maintains the task ledger — what is given, what must be looked up, what can be derived, what is guessed, and the plan. An inner loop maintains the progress ledger — five questions asked every cycle. The design insight: re-planning is triggered by accounting, not vibes. When progress stalls twice, the orchestrator stops and thinks.

📒
What the Ledgers Buy
  • One unchanged configuration across three benchmarks: GAIA 38.0 · AssistantBench 27.7 · WebArena 32.8 — generalist by not over-fitting to any arena
  • Stagnation managed explicitly: a stall counter with ≤2 budget triggers reflection and a revised plan, not endless retries
  • Ablations: −31% without the ledgers; −21% to −39% for removing any single agent — the bookkeeping is the system
  • WebSurfer + FileSurfer + Coder + Terminal on AutoGen — four specialists, zero bespoke glue
⏳
The Price of Generalism
  • Several dollars and tens of minutes per task — generalist loops are not cheap loops
  • No cross-task memory: every task starts from zero — the memory track's whole motivation
  • Fixed five-agent roster: the team can not recruit for the task (contrast MetaGPT's fixed SOPs — same rigidity, different layer)
  • Safety requires human oversight — an agent driving browsers and terminals unattended is a risk, not a demo
Interactive Demo — Run the Outer Loop

A GAIA-style task, live: "What is the height of the waterfall in the photo the user attached?" Watch both ledgers update as the WebSurfer searches, gets stalled by a paywall, and the orchestrator reflects and re-plans. The stall counter is the whole show — when it hits 2, strategy changes.

TASK LEDGER · outer loop
PROGRESS LEDGER · inner loop
stall budget: 0 / 2 used
VERDICT
Generalist = bookkeeping + humility
The −31% ablation without ledgers is the number to remember: the same four specialists, blind, lose a third of the score. Being general is less about having more agents and more about knowing precisely what you know — the given/lookup/derive/guess taxonomy is epistemic hygiene implemented as a prompt. The family debate it settles into: MetaGPT fixed the workflow, Magentic-One fixes the bookkeeping, the survey maps the whole space, and AgentBench grades the results.
🧮 Given · look up · derive · guess
The ledger's fact taxonomy forces the plan to declare its epistemics. Tasks fail differently when guesses are labeled as guesses — the orchestrator can double-check exactly the fragile steps.
🔁 Stall budget ≤ 2
Two unproductive cycles trigger reflection and re-planning. Infinite retry is the default failure of agent loops — a budget converts it into a strategy change.
🏗️ AutoGen substrate
Built on the AutoGen framework: the contribution is orchestration logic, not custom agents. Evidence that the layer above the agents is where generalism lives.
💸 The honest cost column
Dollars and tens of minutes per task, no cross-task memory, safety oversight required. The paper reports its own limits prominently — rare, and necessary for the field's calibration.
Test Yourself

Quick Quiz

Check your understanding of the key concepts from the Magentic-One paper.

Reference

Key Takeaways

Everything you need to remember about this paper.

✅ Magentic-One = 1 Orchestrator + 4 specialists (WebSurfer, FileSurfer, Coder, ComputerTerminal), built on AutoGen — the name fuses "multi" + "agentic".
✅ Outer loop keeps the task ledger (facts: given / look up / derive, guesses, plan); inner loop keeps the progress ledger (five questions per cycle).
✅ Stagnation is managed, not ignored: a stall counter with a ≤ 2 budget triggers reflection and a revised plan instead of endless retries.
✅ One unchanged configuration scored 38.0 on GAIA, 27.7 accuracy on AssistantBench, and 32.8 on WebArena — statistically competitive with SOTA.
✅ Ablations prove the design: −31% without the Orchestrator's ledgers; −21% to −39% for removing any single agent.
✅ Honest limits: several dollars and tens of minutes per task, no cross-task memory, a fixed five-agent roster, and real safety risks requiring oversight.