One-Person Squad: Unified Agency & Automation

• One-Person Squad is a concept where a single human or agent centralizes decision-making, coordinating tasks typically managed by an entire team.
• It spans domains from regulated enterprise software to large-scale robotic swarms and control theoretic games, emphasizing structured supervision and automation.
• Implementations use formal methods, policy fusion, and automated guardrails to convert solo expertise into efficient multi-agent coordination.

One-Person Squad is not a single standardized term in the arXiv literature; rather, it denotes a family of configurations in which one human, one focal agent, or one opposing player assumes responsibilities that are normally distributed across a team. In the cited work, the term and its close analogues refer to a single staff engineer directing four AI agents under a Spec-Driven Development workflow in a regulated brownfield enterprise (Boas et al., 18 May 2026), an Incident Commander coordinating a cohort of semi-autonomous drones (Cleland-Huang et al., 2020), a single Swarm Commander supervising 100+ heterogeneous robots in real urban missions (Adams et al., 2023), a one-versus-many differential game in which one player opposes a squad of regulators (Talebi et al., 2019), and learning frameworks that either build cooperation from solo demonstrations (Wang et al., 4 Nov 2025) or train an ego agent for robust ad-hoc teamwork with unseen partners (Ruhdorfer et al., 8 Aug 2025). Across these uses, the central issue is how concentrated authority, competence, or adversarial agency can be made viable through formal structure, automation, and coordination mechanisms.

1. Core meanings across domains

The literature uses the concept in several distinct but related senses. In software engineering, a one-person squad is explicitly defined as one experienced engineer who takes end-to-end responsibility for delivery while distinct AI agents absorb routine specialist tasks (Boas et al., 18 May 2026). In robotic command-and-control, the same idea appears as a single operator issuing cohort-level directives to drones or supervising very large heterogeneous swarms (Cleland-Huang et al., 2020, Adams et al., 2023). In control theory, it appears as a one-versus-many game in which all players except one are in direct conflict with the remaining player (Talebi et al., 2019). In multi-agent learning, it appears as the conversion of solo competence into coordinated behavior, either by transferring single-agent demonstrations into cooperative MARL or by training one ego agent to coordinate with arbitrary unseen teammates (Wang et al., 4 Nov 2025, Ruhdorfer et al., 8 Aug 2025).

Domain	One-person configuration	Representative source
Regulated enterprise software	One staff engineer + four AI agents	(Boas et al., 18 May 2026)
Semi-autonomous drone cohorts	Incident Commander coordinating multiple drones	(Cleland-Huang et al., 2020)
Heterogeneous robot swarms	Single Swarm Commander supervising 100+ robots	(Adams et al., 2023)
Differential games	One de-regulator versus multiple regulators	(Talebi et al., 2019)
Cooperative MARL	Multi-agent cooperation from solo demonstrations	(Wang et al., 4 Nov 2025)
Ad-hoc teamwork	One ego agent trained for unseen partners	(Ruhdorfer et al., 8 Aug 2025)

Taken together, these sources suggest that “one-person squad” is best treated as an umbrella concept for concentrated supervision or agency under strong automation, rather than as a single architecture or disciplinary term.

2. Mathematical and decision-theoretic formulations

The most explicit one-versus-many formalization appears in All-Against-One Linear-Quadratic Differential games. There, the system dynamics are linear,

$\dot{x}(t) = A x(t) + \sum_{j=1}^{M} B_j u_j(t),$

and all players minimize quadratic costs, but one opposing player encodes de-regulation through negative definite state weights, with $Q_o \prec 0$ and $S_o \prec 0$, while the regulators use $Q_i \succeq 0$ and $S_i \succeq 0$ (Talebi et al., 2019). The closed-loop Nash strategies are linear state feedback laws, and the gains are obtained from a set of coupled Riccati differential equations. The paper derives AAO-specific conditions for definiteness, existence, uniqueness, and boundedness, including the condition that if

$$Q_1 + \sum_{i=2}^M Q_i \succ 0, \qquad S_{1f} + \sum_{i=2}^M S_{if} \succ 0,$$

then the closed-loop state is exponentially bounded, so the opposing player fails in accomplishing its objective (Talebi et al., 2019). In the 3-against-1 pursuit-evasion example, the state is exponentially bounded and the pursuers capture the evader before $t_f=10$; by $t_f=8$, all pursuers are within the 0.1 capture radius. Under Team-Nash, the boundedness conditions are violated, the evader escapes by $t_f=10$, and only by $t_f=18$ does one pursuer get within 0.08 and capture occurs (Talebi et al., 2019).

A different mathematical route appears in Solo-to-Collaborative RL. Solo tasks are formalized as MDPs $Q_o \prec 0$0, cooperative tasks as Markov games $Q_o \prec 0$1, and the cooperative objective is

$Q_o \prec 0$2

SoCo maps solo experiences to cooperation by pretraining a shared solo policy $Q_o \prec 0$3, decomposing each local observation into solo-aligned views, and then selecting and editing action proposals during cooperative training (Wang et al., 4 Nov 2025). The fused action is

$Q_o \prec 0$4

with $Q_o \prec 0$5 obtained by Gumbel-Softmax selection over solo proposals and $Q_o \prec 0$6 as a residual correction (Wang et al., 4 Nov 2025). This formulation makes “one-person squad” literal in the sense that a shared solo prior is instantiated across all agents.

UPD formulates ad-hoc teamwork in a Dec-UPOMDP, with objective

$Q_o \prec 0$7

Its partner generator defines

$Q_o \prec 0$8

where $Q_o \prec 0$9 is a biased random policy generated from a Dirichlet mask, and candidates are scored by a variance-based learnability metric,

$S_o \prec 0$0

In the joint partner-level variant, the paper uses

$S_o \prec 0$1

to keep scores comparable across levels (Ruhdorfer et al., 8 Aug 2025). This formalizes one-agent robustness not as self-play, but as coordination with continually regenerated partner distributions.

3. Human-directed robotic squads and cohorts

In robotic command settings, one-person squad denotes a supervisory configuration in which a single human issues high-level intent while autonomy handles route assignment, local execution, and much of the coordination burden. In the DroneResponse framing, the Incident Commander defines missions and areas, issues cohort- or individual-directed commands by “who, what, where, how,” and the hive-controller creates search plans and assigns routes to drones (Cleland-Huang et al., 2020). The interaction space spans H2D, D2H, D2D, and H2H communication, and the GUI supports predefined mission types, “All/Any/One” addressing, domain-specific commands such as search, deliver, and relay, and map-based region or point-of-interest selection (Cleland-Huang et al., 2020). Drones are semi-autonomous: they can dynamically adjust speed, altitude, and flight plans, switch to track-victim mode upon detection, stream annotated video, and explain their strategies or permissions on demand (Cleland-Huang et al., 2020). Voice and gesture controls were rejected in co-design because ambient noise, radio chatter, drone motors, and environmental error risk made them impractical (Cleland-Huang et al., 2020).

At much larger scale, the OFFSET field exercises showed that a single near-the-battle Swarm Commander used CCAST’s Immersive Interaction Interface, a virtual reality command station built in Unity and SteamVR, to supervise 100+ heterogeneous robots in real urban missions (Adams et al., 2023). The interface combined mission plans, a tactics library, auto-allocation by capability and proximity, tactic visualizations, threat rings, vehicle glyphs, side panels, layer filtering, and saved viewpoints (Adams et al., 2023). Workload was estimated from five components—cognitive, physical, auditory, speech, and visual—and normalized with

$S_o \prec 0$2

The overload threshold was $S_o \prec 0$3, the underload threshold $S_o \prec 0$4, and across 12,181 usable workload estimates there were 377 overload instances, or 3.19%, with no underload instances (Adams et al., 2023). Despite frequent crossings of the overload threshold in acute operational windows, the missions were successfully completed; the paper states, “Stated simply, the answer to the title’s question is: Yes!” (Adams et al., 2023).

The military robotics survey places this within a more constrained near-term doctrine for squads of 3–10 small robots in adversarial urban or mountainous terrain. It argues that a single human can deploy, command, and supervise such a squad only if the team is built around high autonomy, frugal and resilient communications, mission-level control abstractions such as playbooks and policies, lightweight perception and cooperative localization, and decentralized tasking that tolerates outages (Young et al., 2016). The survey favors hybrid deliberative/reactive control, policy-based regulation, market or auction-based task allocation, event-driven notifications, and interfaces that minimize head-down time (Young et al., 2016). It also warns that without these measures a dedicated, trained “Robotic NCO” is typically required to achieve acceptable performance (Young et al., 2016).

A plausible implication is that the viability of a human-centered one-person squad depends less on raw swarm size than on whether command is issued at the level of intent, roles, and mission phases rather than individual vehicle micromanagement.

4. Identity-specific embodied teammates

A narrower but practically important meaning of one-person squad appears in systems that bind a robot to a specific human by identity. The person-specific following robot paper proposes an identity-specific person tracker that fuses an anonymous person tracker with a face recognizer through Sequential Nearest Neighbour with Thresholding Selection (SNNTS) (Chan et al., 2020). The anonymous tracker outputs track positions $S_o \prec 0$5, the face recognizer outputs identities and image-space detections $S_o \prec 0$6, and association is performed in the heading domain using

$S_o \prec 0$7

with admissible matches defined by $S_o \prec 0$8 and a face-score threshold (Chan et al., 2020). The paper uses $S_o \prec 0$9 and short-term identity memory to bridge face-invisibility gaps. In experiments, the proposed method achieved the lowest average absolute tracking error across five scenarios, at 1.47 m versus 1.77 m for SPENCER and 4.68 m for FaceNet, the highest MOTA at 43.0%, and in the person-specific following scenario correctly tracked the target about 90% of the time while the baselines failed partway (Chan et al., 2020).

A related embedded implementation appears in the DeepRacer-based soldier-following system. There, an OpenVINO-optimized SSD detector publishes a normalized image-plane error

$Q_i \succeq 0$0

and a navigation node discretizes the action based on the sign and magnitude of $Q_i \succeq 0$1 and $Q_i \succeq 0$2 into nine qualitative cases (Hossain et al., 2023). The project chose SSD Lite instead of SSD because SSD Lite gave better performance among SSD, SSD with Neural Computing Stick, and SSD Lite, with a considerable boost in inference speed of approximately 2–3 times without compromising accuracy (Hossain et al., 2023). Initial target lock is assigned to the detected person whose box center is nearest to the target center $Q_i \succeq 0$3, and subsequent tracking uses proximity to the previously tracked center and to $Q_i \succeq 0$4 (Hossain et al., 2023).

These systems do not supervise a squad in the swarm sense, but they instantiate a one-person squad capability at the level of embodied assistance: a robot locks onto, follows, and continually assists a single designated person. This suggests that identity persistence and low-latency control are foundational primitives for more complex human-robot one-person squad architectures.

5. AI-augmented software delivery as a one-person squad

The most explicit organizational use of the term appears in a case study of a brownfield regulated enterprise initiative delivered by one staff engineer supported by four AI agents under a Spec-Driven Development workflow (Boas et al., 18 May 2026). The project ran across three three-week sprints in a Brazilian financial institution governed by BACEN and CVM regulations, implemented a digital signature platform for non-account holders, integrated with LACUNA, and touched nine repositories and four microservices with a single user-facing interface (Boas et al., 18 May 2026). The historical baseline was a typical cross-functional squad of four engineers planned to deliver five features and 25 user stories over six sprints, whereas the actual execution used one engineer plus four agents and delivered the same five features and 25 stories in three sprints (Boas et al., 18 May 2026).

The workflow treated the specification as the primary engineering artifact. The canonical rubric contained TASK, TDD AND VALIDATION, SUBMIT WORK, and FORBIDDEN ACTIONS. The agent roles were differentiated: StackSpot acted as a Product Manager Agent for discovery and requirements decomposition; Devin drafted and refined feature specifications grounded across all nine repositories; GitHub Copilot agent mode, under supervision, implemented domain-heavy logic and user-facing flows; and Devin, in autonomous mode, handled integrations, infrastructure, boilerplate, and test generation (Boas et al., 18 May 2026). Mandatory gates included coverage $Q_i \succeq 0$5, static analysis, security scans, WCAG 2.1 AA checks where applicable, integration and E2E tests, manual accessibility sign-offs, and final homologation approval (Boas et al., 18 May 2026).

The reported metrics were unusually explicit. First-review acceptance of AI-generated code was defined as

$Q_i \succeq 0$6

with observed $Q_i \succeq 0$7. The integration test pass rate was

$Q_i \succeq 0$8

with observed $Q_i \succeq 0$9. Time reduction was

$S_i \succeq 0$0

with $S_i \succeq 0$1 sprints, $S_i \succeq 0$2 sprints, and $S_i \succeq 0$3. Direct staffing cost reduction was

$S_i \succeq 0$4

with $S_i \succeq 0$5 plus $S_i \succeq 0$6–7,000 tooling, and $S_i \succeq 0$7. Throughput rose from approximately 0.112 BCP/hour to approximately 0.230 BCP/hour, yielding $S_i \succeq 0$8 (Boas et al., 18 May 2026).

Additional observed outcomes were backend coverage averaging 92.8%, frontend coverage averaging 90.3%, 65 E2E tests with 100% passing, 10 manual accessibility sign-offs, 2 recorded automated checks after tooling addition, 1 post-validation defect, and 0 post-release defects (Boas et al., 18 May 2026). The central conclusion of the study was that the configuration multiplies the throughput of a seasoned engineer and that gains were constrained primarily by specification quality and institutional knowledge, not model capability (Boas et al., 18 May 2026).

The paper is careful about scope. It is a single-case study; no parallel control group was used; the baseline depends on historical BCP comparisons; and practitioner-researcher duality may introduce confirmation bias (Boas et al., 18 May 2026). Even so, it provides a rare operational definition of a one-person squad in enterprise software: concentrated human judgment over a spec-centric workflow, with automated guardrails replacing much of the removed social review loop.

6. Learning teams from solo behavior and unseen partners

In cooperative learning, one-person squad refers less to supervision than to transfer: how solo competence becomes collective behavior. SoCo addresses this directly by pretraining a shared solo policy $S_i \succeq 0$9 from solo demonstrations and then reusing it during cooperative MARL through a policy fusion mechanism consisting of an MoE-like gating selector and an action editor (Wang et al., 4 Nov 2025). The shared solo policy is a 2-layer MLP with hidden size 256, or 128 for Spread, trained by behavior cloning on solo demos with

$$Q_1 + \sum_{i=2}^M Q_i \succ 0, \qquad S_{1f} + \sum_{i=2}^M S_{if} \succ 0,$$0

and then frozen during MARL fine-tuning (Wang et al., 4 Nov 2025). The gating selector uses Gumbel-Softmax to choose among solo-aligned proposals, while the editor applies bounded residual corrections with task-dependent edit strength $$Q_1 + \sum_{i=2}^M Q_i \succ 0, \qquad S_{1f} + \sum_{i=2}^M S_{if} \succ 0,$$1 (Wang et al., 4 Nov 2025).

Training used two phases: solo pretraining from 1M transitions on each corresponding solo task using TD3, followed by multi-agent fine-tuning with MATD3 or HATD3 under CTDE, warm-up of 10k random steps, and task-dependent budgets from 2M to 5M environment steps (Wang et al., 4 Nov 2025). Quantitative results were task-specific. In Spread with 5 agents, SoCo converges faster and outperforms backbones by more than 20% in final performance. In LongSwimmer with 3 agents, HATD3-SoCo achieves approximately 300 average return at about 1.0M steps versus about 1.6M for vanilla HATD3, saving about 40% samples. In MultiHalfCheetah with 3 agents, HATD3-SoCo improves final performance by approximately 83.91% over backbone. In MultiWalker with 2 agents, SoCo improves final performance by 91.51% on HATD3 and 11.97% on MATD3 (Wang et al., 4 Nov 2025). The ablations are equally central: random gating and episode-wise random gating suffer conflicts and poor coordination, learned gating matches Fixed Gating, tanh-based Clip yields smooth gradients and strongest final performance, and $$Q_1 + \sum_{i=2}^M Q_i \succ 0, \qquad S_{1f} + \sum_{i=2}^M S_{if} \succ 0,$$2 fails under domain shift (Wang et al., 4 Nov 2025).

UPD addresses a different problem: ad-hoc teamwork with unknown partners at test time. It generates partners online by stochastically mixing the ego policy with biased random behaviors, scores them with the variance-based learnability metric, and keeps the top $$Q_1 + \sum_{i=2}^M Q_i \succ 0, \qquad S_{1f} + \sum_{i=2}^M S_{if} \succ 0,$$3 in a learnability buffer (Ruhdorfer et al., 8 Aug 2025). The implementation uses Independent PPO with a recurrent actor-critic architecture, 8,192 candidate partners, $$Q_1 + \sum_{i=2}^M Q_i \succ 0, \qquad S_{1f} + \sum_{i=2}^M S_{if} \succ 0,$$4 rollouts per candidate, and a top-$$Q_1 + \sum_{i=2}^M Q_i \succ 0, \qquad S_{1f} + \sum_{i=2}^M S_{if} \succ 0,$$5 buffer of size 512 refreshed every 4 training loops (Ruhdorfer et al., 8 Aug 2025). On Overcooked-AI, UPD achieved the best average performance across unseen partners, with average return 94.4 (8.1), compared with 90.0 (11.0) for UPD w/o $$Q_1 + \sum_{i=2}^M Q_i \succ 0, \qquad S_{1f} + \sum_{i=2}^M S_{if} \succ 0,$$6, 85.6 (11.1) for UPD w/o bias, 76.8 (9.7) for E3T, 67.8 (9.6) for MEP, 45.2 (11.2) for FCP, and 40.4 (10.5) for self-play (Ruhdorfer et al., 8 Aug 2025). In a user study with $$Q_1 + \sum_{i=2}^M Q_i \succ 0, \qquad S_{1f} + \sum_{i=2}^M S_{if} \succ 0,$$7, 144 games total, UPD achieved significantly higher returns than all baselines and was rated significantly more adaptive, more human-like, a better collaborator, and less frustrating (Ruhdorfer et al., 8 Aug 2025). In the joint partner-level generalization setting, JUPD achieved average return 58.9 (5.9), outperforming DR-DR at 49.9 (5.1), SFL-E3T at 44.0 (5.1), and CEC at 23.9 (6.4) (Ruhdorfer et al., 8 Aug 2025).

The two frameworks differ in emphasis. SoCo assumes solo demonstrations are abundant and multi-agent data are costly; UPD assumes no fixed partner population and trains against a dynamic curriculum of generated collaborators (Wang et al., 4 Nov 2025, Ruhdorfer et al., 8 Aug 2025). Both, however, relocate the one-person principle from supervision to representation: either a single shared solo prior is replicated across agents, or a single ego policy is trained to remain effective against a continually changing social environment.

Across these literatures, the recurring bottlenecks are not identical but they are structurally comparable. In enterprise delivery, the stated binding constraints are specification quality and institutional knowledge rather than model capability (Boas et al., 18 May 2026). In large-scale robotic supervision, the limiting factors are communication outages, interface scalability, and human workload (Adams et al., 2023, Cleland-Huang et al., 2020, Young et al., 2016). In cooperative learning, successful transfer depends on structured, decomposable observations, manageable domain shift, and mechanisms for role assignment or partner diversity (Wang et al., 4 Nov 2025, Ruhdorfer et al., 8 Aug 2025). This suggests that the one-person squad is viable when the surrounding system converts many low-level coordination problems into explicit structure: specifications, mission plans, policies, gating mechanisms, guardrails, or feedback laws.