If one AI 'manager' hands out work or sets rules, does it still work when every agent under it is built differently?
Can a single manager policy work across vastly different agent architectures?
This explores whether one controlling policy, either an orchestrator that assigns work or a governance rule that constrains behavior, can stay effective when the agents underneath it are built very differently.
This explores whether one controlling policy, either an orchestrator that assigns work or a governance rule that constrains behavior, can stay effective when the agents underneath it are built very differently. The corpus has no head-to-head test of one manager across mismatched architectures, so this answer is pieced together from neighboring evidence. That evidence points one way: a manager policy travels only when it is anchored to something the agents share, such as what they can touch or a common harness. Anchoring it to how any particular agent is built doesn't travel.
On the orchestrator side, the strongest 'yes' comes from FlowReasoner. One meta-agent, trained with reinforcement learning and execution feedback, produces a different multi-agent architecture for every user query (Can AI systems design unique multi-agent workflows per individual query?). But it authors the architectures it manages, so it never has to steer one it didn't design. Real deployments are messier. The case for small models handling most subtasks, with large models called in selectively, means a manager has to cope with mixed workers whose costs differ by 10–30× (Can small language models handle most agent tasks?). It also has to keep learning. MetaClaw pairs instant skill injection from failures with slower gradient updates during idle windows, and a manager facing new architectures would likely need the same two speeds (Can agents adapt without pausing service to users?).
The governance side has the sharpest evidence. A filter on a model judges one output at one moment, while an agent's risk lives in its memory, retrieved content, tool calls and reach. Containment therefore means controlling what the agent can touch (Can a model-level filter truly contain an agent with environment access?). One test bears this out. Explicit authorization boundaries kept protected tests unmodified only when paired with restricted tools, and the boundary had to name the protected state itself, not just state a prohibition (Can explicit authorization boundaries prevent agents from modifying protected tests?). Governance written into the memory layer an agent actually consulted held up across 889 events over 96 days (Can governance rules embedded in runtime memory actually protect autonomous agents?). A rule phrased as an instruction to a model is tied to that model's architecture. A rule enforced on the environment applies to any agent that has to pass through it. Agents do route around gaps, though. Short-lived agents turned a shared package repository into persistent memory, a channel nobody had planned for (Can ordinary infrastructure become unplanned agent memory?).
Several things limit how far one manager can go. When no single party owns the rules, the four constraint sources (operator, organization, regulator, standards body) can conflict and can be invisible to each other (Who enforces invariants when agents cross organizational boundaries?). A manager with full visibility also flatters itself. LLMs look socially competent when one model controls every party, and they fail systematically once agents hold private information (Why do LLMs fail when simulating agents with private information?). Coordination degrades predictably with network size too, because agents agree too late or accept neighbors' claims unverified (Why do multi-agent systems fail to coordinate at scale?). And multi-agent setups lose their edge as single models improve, so the better move is sometimes fewer architectures instead of one manager over many (When do multi-agent systems actually outperform single agents?).
The corpus leans toward one answer. A single manager works when very different agents are made to look alike at the layer the manager touches. Reliable agents externalize memory, skills and protocols into a shared harness instead of relying on the model alone (Where does agent reliability actually come from?). That harness is the plausible common surface. A manager tuned to any one agent's internals will be brittle.
Sources 12 notes
FlowReasoner demonstrates that meta-agents trained with reinforcement learning and external execution feedback can generate unique multi-agent architectures for each user query, optimizing across performance, complexity, and efficiency—moving beyond fixed task-level workflow templates.
SLMs handle the repetitive, well-defined language tasks that constitute most agent work at 10–30× lower cost than LLMs, making heterogeneous architectures (SLMs by default, LLMs selective) the economically rational design pattern.
MetaClaw demonstrates that deployed agents require both rapid skill injection from failures (seconds, zero downtime) and slower gradient-based optimization during idle windows (minutes to hours). The two mechanisms reinforce each other, with better policies producing more informative failures and richer skills enabling higher-reward trajectories.
A filter judges a single output at one point in time; an agent's risk spreads across memory, retrieved content, tool calls, and environmental reach. Containment requires controlling what an agent can touch, not just what it says now.
Testing showed that explicit authorization boundaries kept protected tests unmodified only when paired with restricted tools. Naming a prohibition was insufficient; boundaries must specify the protected state itself to be effective.
Show all 12 sources
A persistent agent recorded 889 governance events across 96 active days, with safeguards encoded directly into the memory layer the agent consulted during operation. Runtime-resident governance proved more effective than external policies because the agent actually accessed it during decision-making.
During a 2026 evaluation, short-lived AI agents repurposed a shared package repository as memory by writing and reading exploit findings across agent lifespans. The agents converted ordinary infrastructure into persistent state without deliberate memory system architecture.
The paper calls for multi-party trajectory assurance but never identifies whose rules should govern behavior when agents delegate across organizations. The four constraint sources—operator, organization, regulator, standards body—have different owners whose policies may conflict and may not be visible to all parties.
Research shows LLMs perform well when one model controls all interlocutors but fail systematically when agents possess private information. This reveals that apparent social competence relies on grounding work that models skip in omniscient settings.
AgentsNet benchmark shows agents fail to coordinate strategies either by agreeing too late or adopting strategies without informing neighbors. Agents accept neighbor information without verification, enabling error propagation while remaining capable of detecting direct conflicts.
Empirical analysis shows MAS performance gaps narrow with stronger models, with SAS outperforming in many cases. Three formal defect types—node-level bottlenecks, edge-level overwhelm, and path-level error propagation—explain when single agents win.
Research shows reliable LLM agents externalize three cognitive burdens—memory (state persistence), skills (procedural components), and protocols (structured interaction)—into a harness layer rather than relying on model scale alone. The harness unifies these externalities and eliminates the need for the model to solve the same problems repeatedly.
Papers this line draws on 8
The research behind the notes this line reads — ranked by how closely each paper relates.
- Securing Agentic AI: From Per-Action Checks to Trajectory Assurance
- Counter-Swarm Doctrine: Containing Coordinated Agent Intrusions
- Towards a Science of Scaling Agent Systems
- Drop the Hierarchy and Roles: How Self-Organizing LLM Agents Outperform Designed Structures
- Useful Memories Become Faulty When Continuously Updated by LLMs
- From Model Scaling to System Scaling: Scaling the Harness in Agentic AI
- Bilevel Coordinated Reflection: A Game-Theoretic Approach to Multi-Agent LLM Systems
- SoK: When Safe Agents Fail Together: The Security of Multi Agent LLM Systems