aorchestra-agent-orchestration

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)