Manager Clone Agents in Multi-Agent Systems

• Manager Clone Agents are architectures that reify managerial functions by delegating tasks and coordinating subordinate agents via cloning and dynamic synthesis.
• They are applied in multi-agent reinforcement learning, LLM orchestration, and human-AI teams to align incentives and manage agent interactions under varying conditions.
• Key challenges include effective permission management, robust delegation strategies, and integrating incentive modifications without inducing strategic exploitation.

Searching arXiv for the cited papers and recent work on manager-style agent architectures, orchestration, and clone-based delegation. Searching arXiv for papers on manager-style agent architectures, subagent orchestration, clone-based delegation, and incentive-based multi-agent management. Manager Clone Agents are a family of agent architectures in which a higher-level agent supervises, instantiates, coordinates, or emulates managerial functions over subordinate workers, threads, cloned policies, or digital surrogates. Across the recent literature, the pattern appears in several technically distinct forms: an incentive-mediating manager in multi-agent reinforcement learning (Akatsuka et al., 2024), a single LLM acting as a runtime conductor that creates specialized subagents and orchestrates dynamic workflows (Xiong et al., 30 Jun 2026), an autonomous manager for human-AI teams formalized as a Partially Observable Stochastic Game (Masters et al., 2 Oct 2025), a system that dynamically instantiates task-tailored executors from an abstract agent tuple (Ruan et al., 3 Feb 2026), a learned controller that spawns same-weight clones under a fixed inference budget (Li et al., 3 Feb 2026), and workplace-oriented digital surrogates trained on a manager’s communication and decision patterns (Qing et al., 13 Sep 2025). The common structural feature is not a single implementation recipe, but the relocation of planning, delegation, monitoring, and coordination into a distinct managerial layer.

1. Conceptual scope and recurrent design pattern

The literature uses “manager clone agents” and closely related expressions to denote architectures in which managerial function is reified as software rather than left implicit in a monolithic policy. In one line of work, the manager is a dedicated agent that mediates interactions among self-interested agents by assigning incentives and auxiliary states in a general-sum game (Akatsuka et al., 2024). In another, the manager is a main LLM that creates subagents with narrowly scoped permissions, routes work by modality and capability, schedules foreground and background execution, and integrates results into a final deliverable (Xiong et al., 30 Jun 2026). A third formulation defines the Manager Agent as an autonomous orchestrator for dynamic human-AI teams that decomposes goals into task graphs, assigns work, monitors progress, replans, and communicates with stakeholders (Masters et al., 2 Oct 2025).

A closely related but distinct interpretation treats the “clone” literally as an instantiated copy or surrogate. AOrchestra represents any agent as a tuple $\Phi = (I, C, T, M)$—instruction, context, tools, and model—and lets a central orchestrator concretize this tuple into a specialized executor on demand (Ruan et al., 3 Feb 2026). SELFCEST equips a base model with the ability to spawn same-weight clones in separate parallel contexts, so that a root policy can allocate both generation and context budget across branches (Li et al., 3 Feb 2026). In workplace design research, Manager Clone Agents are AI-powered digital surrogates trained on a manager’s communications, preferences, decision patterns, and sometimes appearance or voice, so they can act on the manager’s behalf (Qing et al., 13 Sep 2025).

This suggests that “manager clone agents” is best understood as a structural pattern rather than a single algorithm. The manager may be a separate policy, the same model operating in a root context, a workflow orchestrator over humans and AIs, or a digital stand-in for a human manager. What remains stable is the delegation boundary: the manager does not simply solve the task directly, but reorganizes who acts, on what information, with what permissions, incentives, or budgets.

2. Incentive-mediating managers in multi-agent reinforcement learning

In multi-agent reinforcement learning, the manager-style architecture introduced in “Managing multiple agents by automatically adjusting incentives” adds a dedicated manager agent to a standard multi-agent Markov game (Akatsuka et al., 2024). The motivation is that each agent optimizes its own local reward, which can lead to individually rational but collectively poor outcomes in general-sum games. Rather than imposing full centralized control, the manager mediates interactions among self-interested agents by showing auxiliary states, paying incentives for certain actions, and learning how to do so automatically.

The manager observes a state $s^M_t$ and emits a structured incentive action,

$$a^{M}_t \vcentcolon= [ \hat{s}^{0}_t, ... , \hat{s}^{N}_t, \hat{r}^{0}_t, ..., \hat{r}^{N}_t ] \sim \pi^{M}(s^M_t),$$

where $\hat{s}^i_t$ is an auxiliary state for agent $i$ and $\hat{r}^i_t$ is an auxiliary reward or incentive. In the experimental setup, the manager mainly chooses auxiliary states, written as

$$\hat{a}^{M}_t \vcentcolon= \hat{s}^{0}_{t} \oplus \hat{s}^{1}_{t} \oplus \hat{s}^{2}_{t} \sim \pi^M_t(s^M_t).$$

The manager’s objective is to maximize the sum of raw rewards of all agents while minimizing total payout in incentives,

$$J^{M} = \Sigma_t \gamma^{t}\{\Sigma_i (r^{i}_t - \hat{r}^{i}_t)\},$$

and each agent’s environment is modified as

$$\begin{aligned} s^{i}_t &\leftarrow s^{i}_{t} \oplus \hat{s}^{i}_t, \ r^{i}_t &\leftarrow r^{i}_t + \hat{r}^{i}_t. \end{aligned}$$

The auxiliary reward is defined as

$$\hat{r}^{i}_t = \hat{s}^{i}_{t-1} \cdot a^{i}_{t-1},$$

so the manager can incentivize particular purchase patterns by shaping $s^M_t$0.

The paper evaluates this architecture on a supply-chain optimization problem with 2 suppliers, 3 factories, and 3 retailers. Each environment step spans 7 days; orders are placed on day 1; retailers’ demand is $s^M_t$1 from a flat distribution; demand forecast is demand plus Gaussian noise $s^M_t$2; the OFR target is $s^M_t$3; and weights are $s^M_t$4 and $s^M_t$5 (Akatsuka et al., 2024). The factories are the strategic agents, and the central tension is that supplier 0 is cheaper but has limited capacity, whereas supplier 1 is more expensive but has higher capacity. Without coordination, factories mostly buy from supplier 0, creating bottlenecks that hurt the global fulfillment rate. With the manager, factories buy more from supplier 1, improving OFR and reducing congestion.

Both the agents and the manager are trained with DDPG using MLPs with two fully connected hidden layers of 128 units each, over 500 episodes, averaged over 10 random seeds, with evaluation on the final 25 episodes (Akatsuka et al., 2024). The reported quantitative effects are a raw reward increase of 22.2%, an agents’ reward increase of 23.8%, and a manager’s reward increase of 20.1%. More specifically, naive factories achieve $s^M_t$6, whereas factories with the manager achieve $s^M_t$7; raw rewards are reported as $s^M_t$8; and manager reward is reported as $s^M_t$9 (Akatsuka et al., 2024).

The architecture is explicitly not pure centralized control, because agents still choose their own actions, and it is not merely centralized training with decentralized execution, because the manager actively changes incentives during learning. The paper connects this to Automated Mechanism Design and emphasizes that the setting is multi-step and dynamic, with both manager and agents learning simultaneously. Its main limitation is equally explicit: the method assumes naive learning RL agents, and the authors note that real agents may learn to exploit the manager, behave strategically in more adversarial ways, or fail to adapt in the assumed manner (Akatsuka et al., 2024).

3. Managerial orchestration in language-model agent systems

In LLM systems, the manager clone pattern is typically instantiated as a single main model that creates or controls specialized subagents rather than as a static society of independently designed roles. ClawArena-Team makes this pattern explicit by benchmarking a main agent that is deliberately constrained: it natively perceives only text, directly accesses only part of the workspace, and commands a fixed, locally served subagent pool (Xiong et al., 30 Jun 2026). The manager must create subagents with a system prompt, model key, tool subset, and workspace whitelist; route modality-specific tasks to the correct worker; grant least privilege; schedule work in foreground or background and in new or continued sessions; orchestrate workflows using a programmatic workflow tool with parallel and pipeline primitives; and integrate results rather than merely relay them.

The benchmark spans 41 scenarios, 258 evaluation rounds, and 72 staged update groups, over a heterogeneous workspace of about 170.5 MiB and about 28.9M tokens, with modalities including text, code, office documents, images, audio, and video (Xiong et al., 30 Jun 2026). Its ten hard constraints—unreadable regions, staged updates, full tool surface, at least 8 directories with decoys, non-text modality rounds, parallel-required tasks, session-reuse pairs, cross-round dependencies, modality decoys, and machine-checkable answers—are designed to force genuine management. Performance is summarized by the Subagent-Management Score,

$$a^{M}_t \vcentcolon= [ \hat{s}^{0}_t, ... , \hat{s}^{N}_t, \hat{r}^{0}_t, ..., \hat{r}^{N}_t ] \sim \pi^{M}(s^M_t),$$0

with $$a^{M}_t \vcentcolon= [ \hat{s}^{0}_t, ... , \hat{s}^{N}_t, \hat{r}^{0}_t, ..., \hat{r}^{N}_t ] \sim \pi^{M}(s^M_t),$$1. The strongest empirical result is that privilege granting, rather than perception, is the bottleneck: ROC and MCA are at least 92% for all capable models, TPP is only around 70–80%, and WPP never exceeds 50% (Xiong et al., 30 Jun 2026). The top model, claude-fable-5, attains $$a^{M}_t \vcentcolon= [ \hat{s}^{0}_t, ... , \hat{s}^{N}_t, \hat{r}^{0}_t, ..., \hat{r}^{N}_t ] \sim \pi^{M}(s^M_t),$$2 and $$a^{M}_t \vcentcolon= [ \hat{s}^{0}_t, ... , \hat{s}^{N}_t, \hat{r}^{0}_t, ..., \hat{r}^{N}_t ] \sim \pi^{M}(s^M_t),$$3, but the middle ten models fall within a 9.9-point Sms band even though their orchestration behaviors diverge by more than an order of magnitude.

AOrchestra extends the same managerial logic but replaces a fixed worker menu with dynamic sub-agent synthesis. Its core abstraction is

$$a^{M}_t \vcentcolon= [ \hat{s}^{0}_t, ... , \hat{s}^{N}_t, \hat{r}^{0}_t, ..., \hat{r}^{N}_t ] \sim \pi^{M}(s^M_t),$$4

where $$a^{M}_t \vcentcolon= [ \hat{s}^{0}_t, ... , \hat{s}^{N}_t, \hat{r}^{0}_t, ..., \hat{r}^{N}_t ] \sim \pi^{M}(s^M_t),$$5 is instruction, $$a^{M}_t \vcentcolon= [ \hat{s}^{0}_t, ... , \hat{s}^{N}_t, \hat{r}^{0}_t, ..., \hat{r}^{N}_t ] \sim \pi^{M}(s^M_t),$$6 is curated context, $$a^{M}_t \vcentcolon= [ \hat{s}^{0}_t, ... , \hat{s}^{N}_t, \hat{r}^{0}_t, ..., \hat{r}^{N}_t ] \sim \pi^{M}(s^M_t),$$7 is tool set, and $$a^{M}_t \vcentcolon= [ \hat{s}^{0}_t, ... , \hat{s}^{N}_t, \hat{r}^{0}_t, ..., \hat{r}^{N}_t ] \sim \pi^{M}(s^M_t),$$8 is model (Ruan et al., 3 Feb 2026). The orchestrator’s action space is

$$a^{M}_t \vcentcolon= [ \hat{s}^{0}_t, ... , \hat{s}^{N}_t, \hat{r}^{0}_t, ..., \hat{r}^{N}_t ] \sim \pi^{M}(s^M_t),$$9

so a delegation action instantiates a sub-agent $\hat{s}^i_t$0 on the fly. The system is formulated over trajectories

$\hat{s}^i_t$1

with transition

$\hat{s}^i_t$2

and objective

$\hat{s}^i_t$3

This yields a manager that does not organize a fixed team of roles but synthesizes temporary, task-specific workers by selecting the right instruction, context, tools, and model. The paper reports 80.00 pass@1 on GAIA, 52.86 pass@1 on Terminal-Bench 2.0, and 82.00 pass@1 on SWE-Bench-Verified with Gemini-3-Flash, together with a 16.28% relative improvement against the strongest baseline when paired with the same model (Ruan et al., 3 Feb 2026). It also reports that supervised fine-tuning on Qwen3-8B raises GAIA accuracy from 56.97% to 68.48%, and in-context learning improves GAIA pass@1 from 72.12% to 75.15% while reducing average cost from \$\hat{s}^i_t$$40.57.</p> <p><a href="https://www.emergentmind.com/topics/self-manager" title="" rel="nofollow" data-turbo="false" class="assistant-link" x-data x-tooltip.raw="">Self-Manager</a> presents a related architecture for long-form deep research, but it is careful to classify itself as a single-agent system rather than a multi-agent regime (<a href="/papers/2601.17879" title="" rel="nofollow" data-turbo="false" class="assistant-link" x-data x-tooltip.raw="">Xu et al., 25 Jan 2026</a>). The main thread acts as a manager by spawning subthreads with isolated contexts and controlling them through <a href="https://www.emergentmind.com/topics/thread-control-blocks" title="" rel="nofollow" data-turbo="false" class="assistant-link" x-data x-tooltip.raw="">Thread Control Blocks</a> containing fields such as <code>id</code>, <code>goal</code>, <code>state</code>, <code>allowed_tools</code>, <code>prefix_context</code>, <code>extra_info</code>, <code>start_time</code>, and <code>result</code>. The architecture preserves a single shared policy while allowing asynchronous and concurrent execution. On DeepResearch Bench, Self-Manager achieves Overall 44.33 with Qwen3-30B-A3B, compared with 40.51 for ReAct, 42.77 for <a href="https://www.emergentmind.com/topics/resum" title="" rel="nofollow" data-turbo="false" class="assistant-link" x-data x-tooltip.raw="">ReSum</a>, and 41.79 for FoldAgent, and reduces information-loss$$\hat{s}^i_t$5 to 11.53% relative to 25.23% for ReSum and 19.24% for FoldAgent (Xu et al., 25 Jan 2026). This is manager-like control without separate worker policies.

SELFCEST pushes the clone interpretation further by allowing a root model to spawn helper clones of itself in separate parallel contexts (Li et al., 3 Feb 2026). All workers share the same parameters, but each runs with a different conditioning history $\hat{s}^i_t$6. Training is end-to-end with a global task reward over the full joint trajectory $\hat{s}^i_t$7, using shared-parameter rollouts and GRPO-style outcome supervision. The final update includes rollout gating,

$\hat{s}^i_t$8

where the final method uses the hard protocol gate

$\hat{s}^i_t$9

On long-context multi-hop QA, the method achieves 0.70 on 2WikiMultiHopQA and 0.51 on MuSiQue, compared with 0.65 and 0.35 for the base Qwen3-4B, while using lower average token cost of 644 and 810 tokens respectively (Li et al., 3 Feb 2026). The paper frames this as learned delegation under a fixed inference budget, rather than serial reasoning or uncoordinated parallel sampling.

4. Autonomous manager agents for human-AI teams

“Orchestrating Human-AI Teams: The Manager Agent as a Unifying Research Challenge” treats the Manager Agent as a manager-clone or manager-like autonomous agent whose role is to do for human-AI teams what a human project manager does: turn an ambiguous high-level goal into a coordinated, adaptive workflow (Masters et al., 2 Oct 2025). The paper explicitly contrasts this with the common human-in-the-loop pattern and instead advocates a human-on-the-loop setup, in which the human stakeholder sets goals and oversees while the Manager Agent handles day-to-day orchestration.

The paper formalizes workflow management as a Partially Observable Stochastic Game with tuple

$i$0

where the agent set is

$i$1

with $i$2 the Manager Agent and $i$3 the set of worker agents (Masters et al., 2 Oct 2025). The state is

$i$4

where $i$5 is the task graph and metadata, $i$6 the worker set with capabilities, availability, and cost, $i$7 the communication history, $i$8 the produced artifacts, and $i$9 the stakeholder preference weights. The manager’s action space is divided into observability-increasing actions such as Inspect(T_i) and GetChatHistory(T_i), graph-modifying actions such as AddTask(T_i), RemoveTask(T_i), AddEdge(T_i, T_j), and DecomposeTask(T_i), and delegation or communication actions such as AssignTask(T_i, W_j) and SendMessage(W_j, message).

The paper argues that manager agents are difficult for four foundational reasons: compositional reasoning for hierarchical decomposition, multi-objective optimization under shifting preferences, coordination and planning in ad hoc teams, and governance and compliance by design (Masters et al., 2 Oct 2025). The formalism permits mixed incentives and imperfect coordination; if all agents share the same reward, the POSG reduces to a Dec-POMDP. As a solution concept, the paper mentions Pareto-optimal Nash equilibrium, indicating that a desirable manager should coordinate a team to an outcome that is both stable and efficient.

To support this agenda, the paper introduces Manager Agent Gym as an open-source simulator and evaluation framework instantiated as a discrete-timestep workflow simulator with task graphs, worker pools, communication channels, stakeholder agents, and task execution and validation logic (Masters et al., 2 Oct 2025). Evaluating GPT-5-based Manager Agents across 20 workflow scenarios in finance, legal, healthcare, marketing, technology, operations, and education, the paper reports that no single strategy dominates across domains. Random performs poorly; Chain-of-Thought improves goal completion but is much slower; and Assign-All sometimes improves goal completion by bulk dispatching tasks early but sacrifices constraint adherence and responsiveness. Reported averages include goal completion of about $\hat{r}^i_t$0 for CoT, about $\hat{r}^i_t$1 for Random, and about $\hat{r}^i_t$2 for Assign-All, with corresponding constraint adherence of about $\hat{r}^i_t$3, about $\hat{r}^i_t$4, and about $\hat{r}^i_t$5 (Masters et al., 2 Oct 2025). CoT raises average runtime to 46.9 hours versus 2.7 hours for Random, about 17× slower end-to-end.

A notable empirical distinction is that GPT-5 behaves more like a proactive orchestrator, using 14.5× more decompositions, 7.8× more refinements, and 26× more dependency additions than GPT-4.1, whereas GPT-4.1 is described as more reactive, with more messaging, status checks, and no-ops (Masters et al., 2 Oct 2025). The paper’s broader conclusion is that managerial competence is a distinct AI problem, not a byproduct of stronger chatbot reasoning.

5. Cloning substrates, ensemble coordination, and evaluation under redundancy

The “clone” in Manager Clone Agents can refer not only to delegated subagents but also to cloned workspaces, cloned policies, or redundant strategy instances. TClone addresses the systems layer required for manager-style cloning in computer-use environments by turning a live GUI workspace into a versioned runtime object that can be forked, rolled back, and selectively committed or merged (Huang et al., 17 May 2026). Its abstract operations are fork, rollback, and commit or merge; its design uses sibling containers, copy-on-write memory sharing, filesystem versioning, GUI-local execution, and asynchronous checkpointing. The paper explicitly states that TClone provides the semantics of fork() at the granularity of a full interactive GUI workspace.

For manager-style orchestration, this means an orchestrator can clone the current workspace into multiple agent branches, assign each branch a different plan or tool sequence, run speculative actions in parallel, discard failed branches, and commit only the selected result (Huang et al., 17 May 2026). The evaluation reports clone latency up to 4.9× faster than KVM and 3.4× faster than CRIU, and end-to-end agent-loop latency up to 1.9× faster than KVM and 1.5× faster than CRIU. At 16 concurrent clones, CRIU exceeds 50 s while TClone stays near 10 s, and memory footprint at 16 clones is about 9 GB for TClone versus 14 GB for CRIU. The paper also emphasizes that external side effects such as email sends, payments, and remote submissions are not automatically committed and require restricted networking, delayed release, or explicit approval.

In imitation learning, Swarm Behavior Cloning studies cloned policies rather than a distinct manager policy, but it addresses the coordination problem that arises when multiple cloned agents disagree (Nüßlein et al., 2024). For an ensemble of $\hat{r}^i_t$6 BC policies $\hat{r}^i_t$7, the ensemble action is

$\hat{r}^i_t$8

and the paper identifies increasing action differences in underrepresented states as a source of poor aggregate actions. It defines mean action difference as

$\hat{r}^i_t$9

Swarm BC adds a hidden-state alignment regularizer,

$$\hat{a}^{M}_t \vcentcolon= \hat{s}^{0}_{t} \oplus \hat{s}^{1}_{t} \oplus \hat{s}^{2}_{t} \sim \pi^M_t(s^M_t).$$0

with $$\hat{a}^{M}_t \vcentcolon= \hat{s}^{0}_{t} \oplus \hat{s}^{1}_{t} \oplus \hat{s}^{2}_{t} \sim \pi^M_t(s^M_t).$$1 selected as best and $$\hat{a}^{M}_t \vcentcolon= \hat{s}^{0}_{t} \oplus \hat{s}^{1}_{t} \oplus \hat{s}^{2}_{t} \sim \pi^M_t(s^M_t).$$2 used in the main experiments (Nüßlein et al., 2024). Reported reductions in mean action difference range from nearly 44% in BipedalWalker to about 11% in Ant, and on HalfCheetah with 8 expert episodes the mean scaled return is approximately 0.72 for Swarm BC versus approximately 0.17 for Ensemble BC.

Evaluation under cloned or redundant strategies is addressed by Deviation Ratings, which introduces the first $$\hat{a}^{M}_t \vcentcolon= \hat{s}^{0}_{t} \oplus \hat{s}^{1}_{t} \oplus \hat{s}^{2}_{t} \sim \pi^M_t(s^M_t).$$3-player general-sum clone invariant rating based on coarse correlated equilibria (Marris et al., 17 Feb 2025). Clone invariance is defined so that adding an exact copy of an existing strategy leaves all original ratings unchanged and gives the clone the same rating as the original. The paper rates strategies by deviation gains,

$$\hat{a}^{M}_t \vcentcolon= \hat{s}^{0}_{t} \oplus \hat{s}^{1}_{t} \oplus \hat{s}^{2}_{t} \sim \pi^M_t(s^M_t).$$4

and proves existence, uniqueness, dominance preservation, offset invariance, clone invariance, and mixture invariance (Marris et al., 17 Feb 2025). In LLM evaluation, the paper converts LiveBench model-vs-task data into a three-player general-sum game and reports that the top four models—claude-3-5-sonnet, gemini-1.5-pro, Llama-3.1-405B, and gpt-4o—are rated equally by deviation ratings, reflecting niche structure rather than a forced total order.

6. Workplace surrogates, governance, and common misconceptions

The workplace literature uses “Manager Clone Agents” in a more literal socio-technical sense: AI-powered digital surrogates for managers that are trained on work communications and decision patterns to perform managerial tasks on their behalf (Qing et al., 13 Sep 2025). The paper “When Your Boss Is an AI Bot” studies this through six design fiction workshops with 23 participants total—13 managers and 10 workers—using reflexive thematic analysis over speculative scenarios. It identifies four roles participants envisioned for Manager Clone Agents: proxy presence, informational conveyor belt, productivity engine, and leadership amplifier.

Proxy presence refers to the clone acting as a stand-in in meetings or communications when the manager cannot attend. Informational conveyor belt refers to moving directives downward and feedback upward more consistently and with less social friction. Productivity engine refers to automating repetitive managerial work such as approving invoices, verifying expense claims, processing leave requests, signing weekly timesheets, and completing already-agreed contract and funding steps; some participants estimated this could reduce workload by around 10–15% in their scenarios (Qing et al., 13 Sep 2025). Leadership amplifier refers to extending coaching, mentoring, reminders, and lightweight relational gestures across a larger group than a human manager could normally support.

The same paper stresses that managerial work is relational rather than merely task-based. It organizes risks across individual, interpersonal, and organizational levels: accountability confusion, skill erosion, replaceability anxiety, career blockage, identity threat, fragile trust, authenticity blurring, loss of informal connection, weakened belonging, and culture erosion (Qing et al., 13 Sep 2025). Its design recommendations are worker-centered design, strengthening interpersonal bonds, and enabling tiered autonomy or flexible configuration. Participants preferred graduated control over representation, proactivity, and delegation scope, and the paper explicitly notes that higher realism does not always mean better design.

Several common misconceptions are rejected by the technical literature. First, manager clone systems are not always multi-agent in the strong sense. Self-Manager explicitly says it falls within the category of single-agent systems and does not cross into the multi-agent regime, even though its main thread behaves as a manager over worker-like subthreads (Xu et al., 25 Jan 2026). Second, manager-style orchestration is not equivalent to centralized control. The incentive manager in general-sum MARL alters rewards and observations while leaving action choice decentralized (Akatsuka et al., 2024). Third, strong task performance does not imply strong management performance. ClawArena-Team was built precisely because prior benchmarks did not isolate management skill of a single LLM acting as leader, and it shows that similar aggregate scores can conceal radically different orchestration strategies (Xiong et al., 30 Jun 2026). Fourth, more computation or higher API cost is not a sufficient proxy for better management: in ClawArena-Team, API cost varies by over 100× while Sms varies by under 4×, and in the MA-Gym study stronger reasoning improves some metrics but does not eliminate tradeoffs among goal completion, constraint adherence, and runtime (Xiong et al., 30 Jun 2026, Masters et al., 2 Oct 2025).

Taken together, these results frame governance and alignment as central rather than auxiliary. Permission precision, least-privilege empowerment, accountability boundaries, and stakeholder communication appear repeatedly as bottlenecks or design requirements across benchmarking, workflow management, and workplace deployment.

7. Research significance and open technical questions

The literature converges on the view that managerial orchestration is a distinct problem class. In MARL, the central challenge is aligning self-interested agents with a system-wide objective without forcing full centralization (Akatsuka et al., 2024). In LLM agent systems, the challenge is not only decomposition but also modality routing, permission scoping, session management, asynchronous scheduling, and integration of partial results (Xiong et al., 30 Jun 2026). In human-AI teams, the challenge expands to task-graph editing, multi-objective optimization under shifting preferences, ad hoc teamwork, and compliance by design (Masters et al., 2 Oct 2025). In test-time computation, the issue becomes budgeted delegation: deciding what to parallelize, how much context to send, and how to recombine under a fixed inference budget (Li et al., 3 Feb 2026).

Several open problems are repeatedly identified. Credit assignment remains unresolved in learned clone delegation: SELFCEST notes that exact counterfactual approaches such as difference rewards or COMA-style baselines are too expensive in long-token, multi-rollout settings, so it uses rollout gating as a biased but stable approximation (Li et al., 3 Feb 2026). Robustness to strategic behavior is unresolved in incentive-mediated MARL, because the empirical results assume naive learning agents that do not exploit the manager (Akatsuka et al., 2024). Permission management appears to be the weakest link in runtime orchestration: ClawArena-Team reports that no model exceeds 50% workspace-permission precision, even when modality routing is relatively strong (Xiong et al., 30 Jun 2026). Workflow-level tradeoffs also remain stubborn: in MA-Gym, no single strategy jointly optimizes goal completion, constraint adherence, and workflow runtime across domains (Masters et al., 2 Oct 2025). At the systems layer, workspace cloning is not the same as general semantic merging: TClone explicitly limits commit and merge semantics and treats external side effects as a boundary condition rather than a solved problem (Huang et al., 17 May 2026).

A plausible implication is that future progress will depend less on adding undifferentiated reasoning capacity and more on explicit mechanisms for delegation, scope control, and state management. The existing work already spans incentive design, POSG formalization, runtime subagent synthesis, shared-parameter clone delegation, thread-level context isolation, branchable workspaces, clone-invariant evaluation, and worker-centered governance. As a result, Manager Clone Agents have become a unifying term for a broad research frontier: software systems that reproduce managerial function by deciding how labor, information, permissions, incentives, and attention should be distributed across a coordinated ensemble of human or artificial workers.