[Paper] DyTopo: Dynamic Topology Routing for Multi-Agent Reasoning via Semantic Matching

Source: arXiv - 2602.06039v1

Overview

DyTopo proposes a new way for multiple LLM‑based agents to talk to each other while solving a problem step‑by‑step. Instead of using a static, “everyone talks to everyone” pattern, a lightweight manager rebuilds a sparse, directed communication graph at every reasoning round, routing messages only between agents whose needs and offers actually match. The result is faster, more accurate multi‑agent reasoning on tasks like code generation and math proofs.

Key Contributions

• Dynamic topology routing: Constructs a fresh, sparse communication graph each round based on agents’ expressed needs and offers.
• Semantic matching engine: Embeds natural‑language descriptors and matches them with cosine similarity, turning vague requests into concrete routing decisions.
• Manager‑guided coordination: A central manager supplies a high‑level goal per round, steering the graph‑building process without dictating the exact message flow.
• Interpretability: The evolving graph serves as a visual trace of who talked to whom and why, making the coordination process inspectable.
• Empirical gains: Across four LLM backbones (e.g., GPT‑3.5, Claude, LLaMA‑2) and two benchmark suites (code generation, mathematical reasoning), DyTopo improves average accuracy by +6.2 % over the strongest fixed‑topology baseline.

Methodology

1. Manager goal injection – At the start of each reasoning round the manager emits a concise natural‑language goal (e.g., “refactor the function to use recursion”).
2. Agent self‑description – Each agent, given its private context, replies with:
   • a need sentence describing what information it is looking for, and
   • a key sentence summarizing what it can contribute.
3. Embedding & similarity – All need/key sentences are turned into dense vectors using the same LLM backbone. Pairwise cosine similarity scores are computed.
4. Graph construction – Edges are created from an agent’s need to any other agent whose key exceeds a similarity threshold, yielding a directed, sparse graph.
5. Message routing – Only agents connected by an edge exchange private messages (the actual payload can be a short prompt, a code snippet, or a mathematical hint).
6. Iterative update – After each round, agents update their internal state, the manager issues the next goal, and the process repeats.

The whole pipeline runs with minimal overhead: the semantic matching step is a single matrix multiplication, and the graph is typically under 30 % dense, keeping token usage low.

Results & Findings

• Consistent gains across all four LLM backbones, showing the method is model‑agnostic.
• Reduced token budget: Because only a subset of agents exchange messages, total token consumption per round dropped by ~22 % compared with broadcasting.
• Interpretability demo: Visualizations of the graph over 5 rounds on a code‑refactoring task revealed a clear “search‑then‑refine” pattern—initially many agents queried for function signatures, later only the specialist “refactor” agent communicated with the “test‑generator”.

Practical Implications

• Scalable multi‑agent pipelines: Teams building LLM‑orchestrated assistants (e.g., AI pair‑programmers, automated theorem provers) can adopt DyTopo to keep communication costs low while boosting accuracy.
• Resource‑constrained environments: Edge or on‑prem deployments that pay per token can benefit from the sparse routing, cutting inference spend without sacrificing performance.
• Debuggable AI workflows: The evolving graph gives developers a concrete artifact to audit—useful for compliance, safety checks, or simply understanding why an agent made a particular decision.
• Plug‑and‑play manager: Existing systems that already have a high‑level planner can replace their static broadcast layer with DyTopo’s manager module with minimal code changes.

Limitations & Future Work

• Threshold sensitivity: The similarity cut‑off that decides edge creation is a hyper‑parameter; sub‑optimal values can either over‑connect (wasting tokens) or under‑connect (missing crucial information).
• Manager reliance: The current design assumes a trustworthy manager that supplies sensible round goals; a faulty manager could misguide the entire graph.
• Scalability to hundreds of agents: While experiments used up to 12 agents, the authors note that embedding and matching cost grows quadratically; future work may explore approximate nearest‑neighbor indexing or hierarchical routing.
• Domain‑specific semantics: The semantic matcher is generic; incorporating domain‑specific ontologies (e.g., software engineering vocabularies) could further improve matching quality.

DyTopo opens a promising path toward more efficient, interpretable, and adaptable multi‑agent reasoning—an advance that could make LLM‑driven developer tools both smarter and cheaper to run.

Authors

• Yuxing Lu
• Yucheng Hu
• Xukai Zhao
• Jiuxin Cao

Paper Information

• arXiv ID: 2602.06039v1
• Categories: cs.AI
• Published: February 5, 2026
• PDF: Download PDF