This story was originally published on HackerNoon at: https://hackernoon.com/aorchestra-turns-ai-agents-into-on-demand-specialists-not-static-roles. This is a Plain English Papers summary of a research paper called AOrchestra: Automating Sub-Agent Creation for Agentic Orchestration. If you like these kinds of analysis, join AIModels.fyi or follow us on Twitter. The multi-agent illusion Most AI agent systems today operate under a fundamental constraint: they treat agents as either rigid specialists locked into predetermined roles or as context-isolated threads that lose all accumulated knowledge each time a new agent spawns. This creates a hidden tax on complex problem solving. Imagine a software development team where every time someone switches tasks, they lose access to what they learned before. The front-end developer writes some code, hands it off to the backend developer, but the backend developer doesn't know about the design constraints the front-end developer discovered. Then the backend developer hands off to QA, and QA starts from scratch. Each handoff loses information. Alternatively, you could assign the same person to every role, but then they're constantly context-switching and never developing real expertise. That's the trap existing multi-agent systems face. Researchers have documented this problem across frameworks, recognizing that multi-agent systems struggle with the tension between specialization and coherence. Some attempts at orchestral frameworks for agent orchestration have explored layered approaches, while others have looked at hierarchical structures for multi-agent reasoning, but they still work within this constraint. The first approach treats sub-agents as isolated executors. Each time the system spawns a new agent, it gets only the immediate task. Everything the orchestrator learned is forgotten. This prevents "context rot" (where an agent's context window fills with accumulated, irrelevant details from past steps), but it means every new agent starts cold. If the orchestrator discovered that a user is on macOS or prefers a particular coding style, the next sub-agent never learns it. The second approach assigns sub-agents static, pre-defined roles. You build a "Code Writer Agent," a "Testing Agent," and a "Documentation Agent," each with its own fixed tools and instructions. This preserves continuity and keeps agents specialized, but it's inflexible by design. What happens when a task needs something your pre-engineered agents can't handle? You're stuck. You'd need to anticipate every possible combination of skills beforehand, which defeats the purpose of using AI agents. The deeper issue both approaches share is that they answer the question "What can this agent do?" at design time, not at execution time. The system cannot reshape its team composition to match the task at hand. Comparison of sub-agent-as-tools approaches. (a) Sub-agents as context-isolated threads mitigate context rot but lack on-demand specialization. (b) Sub-agents as static roles provide specialized capabilities but are inflexible. Comparison of sub-agent-as-tools approaches. (a) Sub-agents as context-isolated threads mitigate context rot but lack on-demand specialization. (b) Sub-agents as static roles provide specialized capabilities but are inflexible. A recipe, not a machine AOrchestra begins with a conceptual shift. Instead of thinking of agents as monolithic entities, treat them as recipes. A recipe doesn't describe a machine; it describes how to combine ingredients in a specific way to get a specific result. Any agent, under this framework, can be described as a 4-tuple: Instruction, Context, Tools, Model. Instruction is the task-specific goal or prompt. "Parse this JSON file into Python objects" or "Debug why this test is failing." This piece changes most frequently and is the most specific to the immediate problem. Context is the accumulated state relevant to this particular subtask. If the orchestrator learned that the user's codebase uses type hints, that matters for a code-writing subtask. If the orchestrator knows the user is working in a constrained environment with limited dependencies, that should flow to the next agent. Context connects the dots between steps; it's what prevents each new agent from starting blind. Tools are the executable capabilities the agent can call. A code interpreter. A file reader. A database query interface. A web browser. Different subtasks need different tools. A code-writing agent might need file system access and a Python interpreter. A research agent might need only a search API. By making tools explicit, the system can grant each agent exactly what it needs, no more, no less. Model is the language model performing the reasoning. This is where performance-cost trade-offs live. A simple verification task might run on a fast, cheap model. A complex design task might require a more capable model. The system can choose the right tool for the job. This abstraction is powerful because it's complete and composable. These four components fully specify an agent. By making them explicit, the orchestrator can construct the right specialist for each moment on demand. You don't pre-engineer every possible combination. You assemble them at runtime based on what the task actually requires. How orchestration actually works The orchestrator operates in a deliberate loop. When a user gives it a task, the orchestrator doesn't immediately create one large agent to solve it. Instead, it decomposes the problem and spawns specialized agents one at a time. Here's the decision loop: First, the orchestrator receives the overall task. "Fix this GitHub issue" or "Answer this question using available tools." Second, it identifies the immediate subtask. What's the next step? Does the system need to understand the problem context? Read some files? Write code? Run a test? Each of these is a discrete piece of work. Third, it curates the context dynamically. The orchestrator extracts only the information relevant to this specific subtask from everything it knows. If you mentioned you're using Python 3.11 but the current task is writing JavaScript, that context doesn't travel forward. Keeping context lean means agents spend their tokens on the actual task, not on irrelevant background. Fourth, it selects the right tools. Based on the subtask, the orchestrator grants the agent access to specific capabilities. Need to execute Python? Grant a code interpreter. Need to search the web? Grant a search API. Need to modify files? Grant file system access. To...
