Opening — Why this matters now
Multi-agent LLM systems are having their moment. From coding copilots to autonomous research teams, the industry has embraced the idea that many models thinking together outperform a single, monolithic brain. Yet most agent frameworks still suffer from a familiar corporate disease: everyone talks to everyone, all the time.
This paper introduces DyTopo, a deceptively simple idea with sharp implications: communication itself should be adaptive. Who speaks to whom should change as the task evolves. Not next training cycle. Not via learned weights. At inference time.
Background — Fixed topologies, fixed problems
Most multi-agent systems rely on one of three patterns:
- Broadcast — every agent sees everything.
- Pipeline — agents speak in a fixed order.
- Static graph — a predefined communication structure reused across rounds.
These designs ignore a basic reality of reasoning: early stages reward exploration, later stages demand precision. Treating all rounds the same leads to bloated context windows, redundant messages, and error propagation disguised as collaboration.
DyTopo reframes communication as a stage-dependent resource, not a constant.
Analysis — What DyTopo actually does
DyTopo introduces a manager-guided, round-by-round reconstruction of the agent communication graph.
Each round works as follows:
-
Manager sets a round goal
-
Each agent emits four things in a single pass:
- Public message (for oversight)
- Private message (for routing)
- A Query descriptor — what it currently needs
- A Key descriptor — what it can currently provide
-
Semantic matching embeds all queries and keys and computes cosine similarity
-
A sparse, directed graph is induced based on similarity thresholds
-
Only routed messages update memory for the next round
The crucial design choice: agents do not decide who they talk to. They merely describe needs and offers. Routing is externalized, explicit, and inspectable.
This decoupling keeps agent prompts simple while letting the system rewire itself dynamically.
Findings — Performance and structure
Across code generation and mathematical reasoning benchmarks, DyTopo consistently outperforms:
- Single-agent prompting
- Multi-agent systems with fixed topology
- Random sparse communication
Average gains hover around +6 percentage points, with much larger improvements on difficult math tasks where verification and error localization matter most.
More interesting than raw accuracy is how the system behaves:
| Stage | Topology Characteristic | Purpose |
|---|---|---|
| Early rounds | Dense, exploratory | Problem framing, hypothesis generation |
| Middle rounds | Selective, feedback-driven | Verification, correction |
| Final rounds | Sparse, minimal | Answer assembly |
Communication rounds show non-monotonic returns. More rounds help—until they don’t. DyTopo’s manager-controlled halting avoids the common failure mode of overthinking.
Implications — Why this matters beyond benchmarks
DyTopo quietly solves several practical problems:
- Context efficiency: Sparse routing reduces irrelevant tokens
- Interpretability: Communication graphs form an explicit coordination trace
- Debuggability: Misrouting can be inspected at the descriptor level
- Model-agnosticism: Works across small open models and large proprietary ones
Conceptually, this places DyTopo closer to inference-time systems engineering than model training. It treats LLMs as reasoning modules embedded in a dynamic computation graph.
For anyone building agentic systems, the takeaway is blunt: reasoning failures are often routing failures.
Conclusion — Less chatter, better thinking
DyTopo doesn’t make agents smarter. It makes them quieter—at the right times.
By aligning communication with intent rather than architecture, it demonstrates that multi-agent reasoning scales not by adding more voices, but by knowing when to listen.
Cognaptus: Automate the Present, Incubate the Future.