| name | aorchestra-agent-orchestration |
| title | AOrchestra: Automating Sub-Agent Creation for Agentic Orchestration |
| version | 0.0.2 |
| engine | skillxiv-v0.0.2-claude-opus-4.6 |
| license | MIT |
| url | https://arxiv.org/abs/2602.03786 |
| keywords | ["Agent Orchestration","Multi-Agent Systems","Task Decomposition","Sub-Agent Creation","Framework"] |
| description | Automate sub-agent creation by treating agents as dynamically creatable executors defined by four-tuple abstraction (Instruction, Context, Tools, Model), enabling flexible delegation and cost-aware routing for complex multi-step tasks. |
AOrchestra: Automating Sub-Agent Creation via Dynamic Four-Tuple Abstraction
The orchestration bottleneck in multi-agent systems stems from treating agents as fixed roles rather than dynamic executors. AOrchestra solves this by decoupling orchestration from execution through a unified four-tuple abstraction: each sub-agent is defined by its task instruction, relevant context, available tools, and reasoning model. This enables an orchestrator to spawn task-specific agents on-the-fly rather than managing pre-defined roles, reducing unnecessary context and improving cost efficiency across diverse benchmarks.
Core Concept
AOrchestra models multi-agent systems as two layers: a master orchestrator that only delegates and concludes, and dynamically-created sub-agents that execute specific subtasks. The four-tuple (Instruction, Context, Tools, Model) fully specifies each agent, allowing the orchestrator to optimize per-subtask while maintaining framework-agnostic compatibility with any sub-agent implementation.
Architecture Overview
- Orchestrator Layer: Operates exclusively through two actions—delegating subtasks to spawned agents and returning final answers
- Sub-Agent Instantiation: Each subtask spawns a new agent configured with its task instruction, task-specific context window, required tools, and assigned reasoning model
- Cost-Aware Routing: Learns to select models and tools based on task complexity and performance thresholds
- Learning Mechanisms: Combines supervised fine-tuning for decomposition quality with in-context learning for iterative cost optimization
Implementation
Step 1: Define the Four-Tuple Abstraction
The orchestrator maintains a template for sub-agent instantiation, specifying how to construct each tuple from task decomposition outputs.
def create_sub_agent_tuple(task_decomposition, available_models, available_tools):
"""
Maps task decomposition to four-tuple specification.
Returns: (instruction, context, tools, model)
"""
instruction = f"Solve this subtask: {task_decomposition['subtask']}"
context = retrieve_relevant_context(task_decomposition['subtask'])
tools = select_tools_for_task(task_decomposition['subtask'], available_tools)
model = select_model_by_complexity(task_decomposition['subtask'], available_models)
(instruction, context, tools, model)
