Three Reversals in Multi-Agent Architecture: From Central Scheduling to Self-Driven Collaboration
The article examines three multi-agent collaboration patterns—Master Agent scheduling, Task Board, and Advisor—showing how decision-making control shifts from central orchestration to shared state to on-demand consultation, illustrated with a middleware inspection case study.
Introduction: The Control Problem
When a task requires only a single answer, one agent is often sufficient. But when tasks become long-running workflows—retrieve, analyze, write code, review—the challenge shifts from model intelligence to how the system organizes action. Four organizational questions arise: who decomposes tasks, who assigns them, who judges completion, and what information agents share. All point to the same core issue: where does control reside in the system?
Two Design Boundaries
Context Boundary
Many initially treat multi-agent systems as professional teams (database agent, frontend agent). However, merely swapping role prompts on the same base model rarely yields true specialization. What a model knows depends first on the context it receives; answer quality depends on context relevance. A more useful split is by context boundary and information compression boundary. A code-analysis agent consumes full call graphs, stack traces, and implementation details, compressing them into conclusions a core agent can use. A data-exploration agent processes raw data and anomalies, distilling key findings. The core agent carries only the context relevant to its current decision. This is why "code-analysis agent" and "data-exploration agent" are more practical than "backend agent" or "database agent": the former describe context and output boundaries, the latter are just professional labels amplified by prompts.
Model Boundary
Multi-agent systems also let different models collaborate on one chain. Large models excel at long-chain reasoning, complex trade-offs, and final arbitration but incur higher latency and cost. Small models respond quickly, suiting bulk screening, structured extraction, and early exploration, yet may lose detail on open-ended questions. A practical combination: let small models handle "fast"—scan candidates, extract fields, detect anomalies, compress results into structured clues; then let large models handle "deep"—use those clues to fill context, compare options, resolve conflicts, and own the final result. Models are not simple superior/subordinate replacements; agent boundaries combine speed and quality. However, model switching introduces engineering challenges: small-model outputs need verification, large models must know evidence sources, budgets and timeouts need explicit limits. Only with well-designed output protocols, evidence citations, and fallback mechanisms does "large-small model collaboration" avoid becoming an unexplainable random relay.
Three Collaboration Modes
1. Master Agent Scheduling
The most intuitive form places a Master Agent at the center. It understands the user goal, breaks the task into steps, and routes each step to an appropriate Worker Agent. Workers return results to the Master, which decides the next step and finally aggregates. For example, a "research and write technical report" job: Research Agent gathers materials, Analyst Agent extracts insights, Writer Agent composes the article. Each worker does its local part; the Master orchestrates the flow.
Advantages: Clear control flow—who runs first, who runs next, which results pass downstream—all observable and modifiable in one place. Permissions, budgets, timeouts, and failure handling are easier to manage centrally. Valuable for fixed processes with explicit dependencies.
Drawbacks: As complexity grows, the Master Agent must not only reason but also remember all worker states, handle intermediate results, and continuously judge routing. It risks becoming a "super agent" that understands business, maintains a scheduler, state machine, and exception handling. Suitable for stable workflows, strict sequencing, unified permission control, or automation with fixed order.
2. Task Board
This architecture moves "task assignment" out of the Master Agent's internal reasoning into a shared board visible to all agents. The board records pending tasks, assignees, dependencies, execution status, and artifacts. Agents no longer wait for the Master to call them; they actively check the board and claim tasks they can handle.
Key reversal: Scheduling no longer appears as "Master Agent issues commands" but as "shared state exposes opportunities." Agents choose based on their capabilities and current state, then update the board; new status makes downstream tasks executable.
Collaboration protocol challenges: When two agents see the same task, who claims it? If a claiming agent crashes, how is the task reclaimed? How does a completed task release downstream dependencies? How to keep results idempotent on retries? Therefore, the board typically works with a task state machine: PENDING → CLAIMED → RUNNING → SUCCEEDED / FAILED / RETRYING. Claiming requires locks or leases; state changes leave history; task outputs pass via stable references, not stuffed into the next prompt.
The board shifts central scheduling pressure to state management and consistency. It sacrifices some intuitiveness for better parallelism, elastic scaling, and fault recovery. Adding a new agent usually doesn't require changing a monolithic router. Fits high task volume, high parallelism, long execution, or checkpoint-recovery systems: batch data processing, code repository scanning, continuous research, background workflows.
3. Advisor
The first two architectures discuss "who arranges tasks." Advisor flips the angle: the main flow is driven by the executing agent; only at high-risk judgments, domain blind spots, or design disagreements does it proactively seek another agent's opinion.
The Advisor does not take over the task or call tools for the executor. It provides a second opinion: security assessment, architecture review, domain knowledge, or a counter-argument to the current plan. The executing agent decides whether to adopt the advice.
Responsibility boundary shift: Master Agent calls Worker Agent; Advisor is called by the executing node. This changes the system's responsibility boundary: the executor retains full context and main flow; the Advisor contributes extra cognition only on local decisions.
Example: A Coding Agent modifying a payment module suspects its design may affect idempotency and transaction boundaries. It sends the current design, relevant code, and specific questions to an Architecture Advisor. The Advisor returns risks and alternatives; the Coding Agent combines test results to decide whether to adjust. The Advisor needs neither the full project history nor direct code-edit permissions.
This mode suits high-uncertainty tasks not worth pre-orchestrating into fixed flows: code review, security assessment, product design comparison, domain consultation. Note that consultation has cost: when to ask, what to ask, how much context to provide, and how to judge advice adoption must become part of the agent's capability.
Three Reversals: Control Sinking
Placing the three architectures together, the clearest difference is not component count but control shift. They represent three organizational philosophies:
Master Agent: "I tell you what to do."
Task Board: "Look at what tasks are ready to do."
Advisor: "You proceed; I'll advise when needed."
Control moves from a central node → shared state → the current executor.
Case Study: Middleware Inspection
Inspection Challenges
An inspection request: "Check the three middleware components our team owns over the last hour, focus on ongoing anomalies, and give troubleshooting suggestions." This involves multiple components, metric types, and massive time-series samples. Different metrics map to different instances, nodes, or interfaces. Dumping all raw data into one agent's context raises cost and drowns real anomalies in normal data. Analysis duration varies: some batches finish fast, others need more exploration, some may be interrupted. Meanwhile, peak-in-window, currently anomalous, and insufficient data represent three distinct situations; explaining a threshold breach requires another layer of judgment.
Master Agent: Intent & Routing
The entry Master Agent extracts the user's requested components, time window, and focus, then delegates to corresponding Inspector Agents. It only needs each Inspector's capability description, input requirements, and invocation endpoint. Metric catalogs, target discovery, task decomposition, and analysis methods are managed by the Inspector Agent itself. The Master's central role is limited to component-level routing: it does not track individual analysis batches. Component-level planning, evidence aggregation, and completeness checks belong to the Inspector. When component reports return, the Master preserves each component's factual boundary and assembles the final result. Changes in underlying metrics, tools, or grouping strategies stay inside the component inspection unit.
Task Board: Parallelism & Self-Healing
Inside a component, the Inspector Agent breaks work into independent tasks of "metric + target batch + time window" based on the metric catalog and completeness goals. In the shared-board approach, the Inspector publishes analysis targets; multiple Worker Agents claim tasks in parallel based on capability and available capacity. Progress and results converge on the board.
Workers call deterministic statistical tools to compute peaks, threshold breaches, and observed durations, then submit concise evidence: anomalous objects retain necessary details; normal objects are compressed to summaries. Raw time-series remain in the tool layer; the Inspector verifies anomalies and coverage from this evidence.
If a Worker Agent exits mid-execution, completed batches' evidence stays on the board. The interrupted task's lease expires, another Worker picks it up; with limited retries and idempotent submission, only unfinished batches are re-run. This maintains parallel processing and recovers from local interruptions without a full re-run.
The Inspector finally verifies task coverage, distinguishing current anomalies, window-recovered cases, and data gaps. Ranges still incomplete at the overall deadline are recorded as limitations; targets with no data are explicitly marked to avoid the fallacy "no anomaly found, therefore everything is normal."
Advisor: On-Demand Consultation
After aggregating evidence, the Inspector Agent first judges whether unexplained issues remain. For short-lived breaches that have recovered with sufficient evidence, it states status and limitations directly. When correlated metrics are puzzling, potential causes diverge, or extra domain knowledge is needed, it submits specific questions to a Root-Cause Analysis Advisor (RCA Advisor).
Example: The Inspector sends anomalous objects, peaks, durations, and correlated metrics from the same window, asking whether traffic changes explain resource pressure. The Advisor returns possible causes and verification directions: "Both are temporally close; suggest verifying with corresponding runtime logs; current evidence insufficient to confirm root cause."
The Inspector validates and adopts advice, preserving uncertainty markers like "possible" and "to be verified" in the report. If the Advisor times out or fails, the system still outputs the evidence-backed baseline conclusion; self-explainable issues are finalized directly, controlling consultation cost.
The final user-facing report remains organized by component: current anomalies, recovery status, data limitations, and necessary troubleshooting suggestions. Collaboration details stay internal; every conclusion traces back to its task evidence.
Conclusion: Matching Control
The evolution of multi-agent systems is not mechanically replicating more agents, but continually rearranging who holds decision rights. Master Agent centralizes decisions; Task Board encodes decisions into shared state; Advisor returns decisions to the executing agent.
Therefore, architecture choice should match control to the problem: steps needing unified sequence go to orchestration; parallelizable tasks are coordinated by shared state; in-execution professional doubts are supplemented by on-demand consultation. As tasks change, the boundaries of these responsibilities are adjusted.
Signed-in readers can open the original source through BestHub's protected redirect.
This article has been distilled and summarized from source material, then republished for learning and reference. If you believe it infringes your rights, please contactand we will review it promptly.
How this landed with the community
Was this worth your time?
0 Comments
Thoughtful readers leave field notes, pushback, and hard-won operational detail here.
