🤖 AI

Retrieval-Conditioned Topology Selection with Provable Budget Conservation for Multi-Agent Code Generation

This paper introduces Retrieval-Guided Adaptive Orchestration (RGAO), a multi-agent framework that dynamically selects code generation topologies based on structural complexity extracted from a hierarchical code index, thereby achieving provable budget conservation through the novel integration of complexity-conditioned routing and formal resource algebras.

Original authors: Abhijit Talluri, Pujith Anne, Bhagavan Choudary Pendiyala, Raghavendra Chilukuri

Published 2026-05-08

📖 4 min read☕ Coffee break read

CC BY 4.0

Original authors: Abhijit Talluri, Pujith Anne, Bhagavan Choudary Pendiyala, Raghavendra Chilukuri

Original paper licensed under CC BY 4.0 (http://creativecommons.org/licenses/by/4.0/). ✨ This is an AI-generated explanation of the paper below. It is not written or endorsed by the authors. For technical accuracy, refer to the original paper. Read full disclaimer

Imagine you are the manager of a team of highly skilled, but very expensive, AI assistants. Your goal is to fix bugs or write new code for a massive software project.

The problem with current AI teams is that they are clueless about the job size.

If you ask them to fix a typo in a single file, they might send in the whole "Swat Team" with a crane, a bulldozer, and a demolition crew. This is a waste of time and money.
If you ask them to rebuild an entire city's power grid (a complex change across many files), they might send in just one person with a screwdriver. This leads to failure.

This paper introduces a new system called CODE-AGENT with a special manager named RGAO. Here is how it works, using simple analogies:

1. The "Scout" Before the "Crew" (Retrieval-Guided Routing)

In old systems, the manager looked only at the words you typed to decide who to send. If you said "fix the login," they assumed it was a big job.

RGAO changes the game. Before sending anyone, it sends out a Scout to look at the actual code.

The Scout climbs the code structure (like a tree) and measures things like: "How deep are the roots?" "How many branches are tangled?" "How many different buildings does this affect?"
Based on this structural map, the manager picks the right team:
- FASTPATH: A tiny typo? Send one person to fix it instantly.
- SUBAGENT: A small feature? Send one specialist.
- MULTIAGENT: A big change? Send a pipeline of experts working together.
- DEEPRESEARCH: A confusing, vague request? Send a team to do heavy research first.

The Result: The paper claims this "Scout" method reduced the number of wrong team assignments from 30% down to 8%. It's like a general looking at a map before deciding whether to send a sniper or an army.

2. The "Unbreakable Budget" (Provable Budget Conservation)

AI agents are expensive; they use up "tokens" (like fuel) and time. If an agent gets stuck in a loop or goes crazy, it can burn through your entire budget in seconds.

The authors created a Mathematical Safety Net.

Think of the main manager as a parent with a $100 allowance.
When the parent sends a child (a sub-agent) to do a task, they give the child a strict allowance (e.g., $10).
The system has a mathematical proof (Theorem 1) that says: "No matter how many children you send, or how many times they try again, the total money spent by the whole family will never exceed the parent's original $100."

Why this is special: Most systems check the budget while the work is happening (and if they run out, it's too late). This system checks the math before anyone starts working. If the plan looks like it will cost $110, the system says "Nope, cancel this plan" before a single dollar is spent.

3. The "Assembly Line" (Architecture)

The system works in layers:

The Scout: Reads the code tree and measures complexity.
The Dispatcher: Uses the measurements to pick the right team size.
The Accountant: Checks the math to ensure the team won't overspend.
The Workers: The actual AI agents do the coding, passing notes to each other efficiently without shouting over everyone (which saves time).

The Bottom Line

The paper claims this combination—looking at the code structure first and mathematically guaranteeing you won't overspend—creates a system that is much smarter about who to send and how much it will cost.

Important Note from the Paper:
The authors are honest about the limits. They tested this on a "proxy" (a simulation) because running the full real-world tests is too expensive and risky right now. They also admit that if the code is in a language their "Scout" doesn't know well (like Rust, which they are still learning), the system isn't quite as sharp. But for the tests they ran, it worked significantly better than the old "guess based on keywords" methods.

Technical Summary: Retrieval-Conditioned Topology Selection with Provable Budget Conservation for Multi-Agent Code Generation

Problem Statement

Multi-agent Large Language Model (LLM) systems for code generation face a fundamental routing challenge: determining the optimal orchestration topology (e.g., monolithic, single-specialist, pipeline/swarm, or retrieval-heavy) based on the structural complexity of the code being modified. Existing systems typically select topologies using surface-level query features (e.g., regex classifiers) or task dependency graphs without consulting the actual codebase structure. This leads to "misrouting," where simple edits are routed through complex pipelines or vice versa, incurring unnecessary efficiency penalties. Furthermore, while formal resource algebras exist to manage agent budgets, they often lack integration with dynamic topology selection, and resource guarantees are frequently enforced only at runtime rather than statically.

Methodology: CODE-AGENT and RGAO

The paper introduces CODE-AGENT, a multi-agent framework centered on Retrieval-Guided Adaptive Orchestration (RGAO). The system operates through a closed loop where retrieval signals directly inform orchestration decisions, coupled with a formal budget algebra that guarantees resource conservation.

1. Hierarchical Code Retrieval & Complexity Extraction

Before routing, the system performs a retrieval pass over a hierarchical tree index of the code repository (Root $\to$ Directory $\to$ File $\to$ Symbol).

Retrieval Strategy: Queries are classified into five types (identifier, exact, conceptual, dependency, structural). Conceptual queries trigger a multi-path fusion strategy combining LATTICE (path-score calibration), KohakuRAG (multi-query reformulation), and PageIndex (LLM-guided beam search), fused via Reciprocal Rank Fusion (RRF).
Complexity Vector ( $c$ ): From the retrieved subgraph, RGAO extracts a five-dimensional structural complexity vector in sub-millisecond time:
$c = (d_{dep}, n_f, n_s, h_t, \rho_x)$
Where $d_{dep}$ is max dependency depth, $n_f$ is file count, $n_s$ is symbol count, $h_t$ is tree depth, and $\rho_x$ is cross-module coupling ratio.

2. Retrieval-Guided Adaptive Orchestration (RGAO)

The topology router is a deterministic threshold classifier that maps the complexity vector $c$ and the user query to one of four topologies:

FASTPATH: Monolithic execution for trivial, single-file edits.
SUBAGENT: Single specialist contract for moderate scope ( $n_f \le 3$ ).
MULTIAGENT: Linear pipeline or parallel swarm for complex, multi-file tasks ( $n_f > 3$ ).
DEEPRESEARCH: Multi-stage, retrieval-heavy execution for ambiguous queries.

3. Formal Budget Algebra & Static Verification

Sub-agents are governed by formal contracts $\langle I, C, T, M \rangle$ , where $C$ includes a six-dimensional budget vector (iterations, calls, tokens, seconds, retries, handoffs).

Budget Conservation Theorem (Theorem 1): The paper proves that under specific assumptions (deterministic tool costs, bounded retrieval depth, finite action space), the total resource consumption of a delegation forest is bounded by the root budget.
Static Verification: A VERIFYCONSERVATION algorithm checks the budget algebra in $O(|V| + |E|)$ time before any LLM call is made. It ensures that the sum of child budgets plus direct costs does not exceed the parent's budget, preventing resource overruns statically rather than reactively.

4. Execution Layer

The system utilizes a SwarmSupervisor to build a Directed Acyclic Graph (DAG) of tasks. It enforces a three-gate pre-execution protocol (contract existence, budget feasibility, handoff integrity) and uses typed SwarmArtifact objects for inter-agent communication, reducing coordination overhead from $O(n^2)$ to $O(k)$ .

Key Contributions

Complexity-Conditioned Topology Router: A router that maps retrieval-derived code-structure signals to orchestration decisions, reducing misrouting rates significantly compared to regex-based baselines.
Provable Budget Conservation: A structural-induction theorem (Theorem 1) ensuring hierarchical contract delegation never exceeds parent bounds, verified statically in linear time relative to the DAG size.
Hierarchical Retrieval Engine: A novel combination of LATTICE, KohakuRAG, and RepoGraph-style dependency expansion over a tree-structured index, used specifically as a routing signal.
System Composition: The integration of retrieval-conditioned routing with static budget verification, a property neither component admits alone.

Empirical Results

Evaluation was conducted using a proxy harness (evals/swebench_proxy.py) to abstract sandboxed interactions, with full SWE-bench runs deferred to a follow-up pass due to contamination concerns and resource constraints.

Routing Accuracy: On a 250-instance labeled dataset, RGAO reduced misrouting from 30.1% (regex baseline) to 8.2% (95% Wilson CI [6.1, 10.9]), a statistically significant improvement (paired McNemar, $p < 10^{-6}$ ).
Performance Overhead:
- DAG construction: Sub-millisecond (< 0.01 ms).
- Tree index build (200 files, 2,002 nodes): 11.1 ms.
- Contract factory instantiation: ~1.1 $\mu$ s.
- Budget check overhead: ~0.65 $\mu$ s.
Pipeline Correctness: The system completed 100% of five compound multi-agent pipelines (including intervention recovery scenarios) with a mean token cost of ~6,000 tokens per pipeline.
Proxy Benchmarks: CODE-AGENT resolved 40% of a synthetic SWE-bench set at pass@1, demonstrating efficiency compared to unconstrained monolithic agents (8–20x token reduction).

Significance and Claims

The paper claims its primary significance lies in the composition of two previously separate research lines: complexity-conditioned LLM routing and formal resource algebras.

Novelty: Neither complexity-conditioned routing nor formal budget algebra alone yields the property of "provable budget conservation under retrieval-conditioned dynamic topology selection."
Safety & Efficiency: The static verification mechanism allows the system to reject infeasible configurations before execution, bounding the "blast radius" of agent errors and lowering the cost barrier for agentic code generation in resource-constrained environments.
Interpretability: Unlike learned routing policies, the RGAO router uses interpretable, hand-tuned thresholds based on structural signals, aligning with the contract-based safety story.

The authors acknowledge limitations, including the reliance on deterministic cost assumptions for the strict conservation theorem (though expected bounds are provided for stochastic costs) and the current use of hand-tuned thresholds rather than a learned successor. They note that the routing advantage narrows under distribution shifts (e.g., unfamiliar languages) where the tree-sitter grammar may degrade the complexity vector.