AOrchestra: Agentic Orchestration Framework

• Agentic System AOrchestra is a compositional framework that defines agents via a parameterizable four-tuple (Instruction, Context, Tools, Model).
• It dynamically instantiates specialized sub-agents through a central orchestrator that decomposes tasks for efficient performance and cost control.
• Empirical benchmarks show AOrchestra’s significant improvements over traditional frameworks, achieving up to 54% Pass@1 relative gains.

Agentic System AOrchestra

AOrchestra denotes a framework-agnostic, compositional architecture for agentic orchestration systems, enabling dynamic instantiation and orchestration of specialized sub-agents for complex, long-horizon tasks. The central innovation of AOrchestra is its unifying abstraction of agents—both orchestrators and sub-agents—as parameterizable four-tuples: Instruction, Context, Tools, Model. This tuple-based formalism supports dynamic task decomposition, performant and cost-efficient agent instantiation, and seamless integration of heterogeneous agent implementations. Empirical evaluation demonstrates substantial performance improvements over existing agentic meta-frameworks across multiple high-difficulty benchmarks (Ruan et al., 3 Feb 2026).

1. Unified Agent Abstraction

AOrchestra is predicated on the view that every agent—be it the main orchestrator or any sub-agent—can be represented as a four-tuple:

$\Phi = (I,\,C,\,T,\,M)$

where:

• $I$ (Instruction): Textual specification of what the agent must achieve.
• $C$ (Context): Curated working memory, restricted to information relevant to the current subtask.
• $T$ (Tools): Finite set of tool-actions available to the agent (e.g., web search, shell commands, code edits).
• $M$ (Model): The LLM or foundation model driving the agent’s reasoning/generation.

By filling in these four components, AOrchestra can dynamically spawn specialized executors tailored to the granularity and requirements of each subtask. This abstraction provides a schema-agnostic compositional “recipe” for agent capabilities, supporting plug-and-play integration and facilitating automated task decomposition (Ruan et al., 3 Feb 2026).

2. Central Orchestrator Policy and Workflow

The orchestrator in AOrchestra is itself a $$(I^\text{main},C^\text{main},T^\text{main},M^\text{main})$$ agent, but its toolset is restricted to two actions: $\mathrm{Delegate}(\Phi)$ (spawning a sub-agent) and $\mathrm{Finish}(y)$ (returning the final output). The orchestrator alternates through:

• Decomposition & 4-tuple Synthesis: Synthesize the next subtask $I_t$, extract minimal relevant context $C_t \subset C^\text{main}$, select model $M_t$, and determine the minimal tool subset $T_t$ to cover $I_t$;
• Delegation: Call $\mathrm{Delegate}(I_t,C_t,T_t,M_t)$ to instantiate the sub-agent;
• Incorporation: Receive and parse the sub-agent’s structured report $o_t$, incorporating only salient outcomes back into $C^\text{main}$.

At each orchestration round, this design ensures agents are instantiated with exactly the information, capabilities, and reasoning resources required by their immediate subtask, leading to high adaptability and reduced spurious resource usage. Pseudocode formalizations for this workflow specify iteration over a bounded number of decomposition-execution rounds, with fallback to best-effort completion if the task cannot be achieved within a given budget (Ruan et al., 3 Feb 2026).

3. Performance–Cost Optimization and Control

AOrchestra explicitly incorporates a trade-off objective between pass-at-1 task success and cumulative agentic system cost:

$$\max_\pi \mathbb{E}\!\left[\mathbf{1}\{\text{Success}\} - \lambda \cdot \mathrm{Cost}(\tau)\right]$$

where $\mathrm{Cost}(\tau)$ aggregates LLM token costs (per model-pricing schedule), API/tool-call costs, and latency penalties. Runtime control is achieved via:

• Model Routing: Sub-agent instantiations are assigned to models from a catalog $\{\text{cheap model},\ldots,\text{strong model}\}$, using prompt-level reminders and real-time budget tracking.
• Supervised Fine-Tuning (SFT): Expert-curated orchestrations are used to pre-train the orchestration policy $\pi$ to achieve more steps with fewer agents where possible.
• Iterative In-Context Learning (ICL): System prompt instructions are updated via optimization LLMs, shifting the performance–cost Pareto frontier.

This enables tunable performance–cost behavior, realizing Pareto-efficient frontiers on challenging benchmarks (e.g., GAIA), and adaptively balancing task scalability with rapid or budget-constrained completion (Ruan et al., 3 Feb 2026).

4. Framework-Agnostic, Plug-and-Play Sub-Agent Integration

Sub-agents in AOrchestra are instantiated solely through their four-tuple interface $\Phi_t = (I_t, C_t, T_t, M_t)$. Critically, the orchestrator is agnostic to the internal implementation of the sub-agent; as long as the agent interprets $(I_t,C_t)$ as input, restricts itself to $T_t$, is driven by $M_t$, and returns a structured report (e.g., JSON), it can seamlessly operate within the AOrchestra system.

Supported agent instantiations include ReAct-style LLM wrappers, mini-SWE code agents with Python REPL/test runners, external agents (e.g., Anthropic Claude Code agents), and any tool-augmented agent conforming to the 4-tuple contract. This architecture eliminates tight coupling between orchestration logic and sub-agent implementation, enabling rapid extension and future-proofing (Ruan et al., 3 Feb 2026).

5. Empirical Benchmarking

AOrchestra was empirically evaluated on three demanding agentic task suites:

• GAIA: Web and multimodal Q&A, 165 tasks.
• Terminal-Bench 2.0: Bash terminal automation, 89 tasks.
• SWE-Bench-Verified: Real-world GitHub issue triage and patching, 500 tasks.

Using Gemini-3-Flash as both orchestrator and sub-agent model, the system achieved: | Benchmark | Best Baseline Pass@1 | AOrchestra Pass@1 | Relative Improvement (%) | |:---------------------------:|:--------------------:|:-----------------:|:-----------------------:| | GAIA | 66.06 (OpenHands) | 80.00 | +21.1 | | Terminal-Bench 2.0 | 34.29 (mini-SWE) | 52.86 | +54.1 | | SWE-Bench-Verified | 60.00 (ReAct) | 82.00 | +36.7 | | Overall Average | 53.45 | 71.62 | +34.0 |

When pooling results, AOrchestra yields an average +16.28 percentage-point improvement in Pass@1 data over the strongest competitive agentic frameworks under matched backbone conditions (Ruan et al., 3 Feb 2026).

6. Broader Architectural Context

The AOrchestra design, as articulated in (Nowaczyk, 10 Dec 2025), emphasizes closed-loop, modular orchestration with stage-wise governance, budget/termination enforcement, and strong interface disciplines (JSON/YAML schemas, least-privilege capability tokens, idempotent tool calls). Each orchestration stage—goal management, planning, tool routing, execution—is isolated by explicit API and eventing boundaries, with telemetry, memory provenance, and verification modules orthogonal to workflow control. Patterns such as supervisor-worker, peer debate, and voting emerge naturally within this control architecture. These interface and control schemas ensure that agentic systems built atop AOrchestra are robust, auditable, and extensible for open-ended, high-complexity reasoning workflows (Nowaczyk, 10 Dec 2025).

7. Relation to Other Agentic Orchestration Frameworks

Other agentic meta-orchestration architectures, such as the Agentic Meta-Orchestrator (AMO) for Copilot services (Zhu et al., 26 Oct 2025), Alpha Berkeley (Hellert et al., 20 Aug 2025), and distributed scales like MegaFlow (Zhang et al., 12 Jan 2026), implement comparable plug-and-play, dynamic capability composition and orchestration patterns. However, AOrchestra’s explicit four-tuple agent definition, runtime sub-agent generation, and fine-grained cost–performance trade-off optimization represent a distinct formalism. In particular, the tuple formulation allows for runtime instantiation of arbitrarily specialized agents, and enables tuning of model assignment and resource usage granularly per subtask, a property that is not systematically embodied in prior orchestration frameworks. This highlights AOrchestra’s contribution as a generalized, compositional substrate for scalable and adaptable agentic reasoning (Ruan et al., 3 Feb 2026).