The Coherence Challenge in AI Swarms: A Case Study with FastRender

In a fascinating experiment, 2,000 AI agents built a working browser engine in just one week using over 1.7 million lines of Rust code. This ambitious project, known as FastRender, was a technical success-code ran, tests passed, and features worked. However, the deeper implications highlight a critical issue: swarm divergence.

When Agents Diverge

Consider this scenario: two AI agents independently need an HTTP client. Both ask the same question:

• Agent A: "What Rust crate should I use for HTTP requests?"
• Agent B: "What Rust crate should I use for HTTP requests?"

They receive different answers-perhaps reqwest vs. ureq. This divergence isn't a bug; it's a natural outcome of how swarms operate. Each agent makes locally reasonable choices, but the aggregate result lacks coherence.

Why Divergence Matters

For FastRender’s goals, this wasn't a problem. Both crates worked, and the browser rendered pages successfully. However, the experiment raises important questions about reproducibility and consistency:

• Reproducibility: If you ran the experiment again with different temperature samples, task assignments, or model updates, you might get different results. The output is a sample from a distribution, not a deterministic function.
• Compatibility: What if the divergence was more fundamental? One agent picks an async HTTP client, another picks a sync one; one expects errors as Result, another expects panics; one assumes UTF-8 encoding, another assumes bytes. These incompatibilities can lead to code that doesn't compose.

Rust’s Role in Convergence

Rust's strong type system and compiler checks provide a safety net against these issues:

• Compiler Verification: In Rust, cargo check would catch mismatches. If one function returns a Result and another expects a panic, the compilation fails. The compiler acts as an implicit verifier, forcing convergence through feedback.
• Error Messages: Rust’s clear error messages can provide agents with enough information to self-correct, leading to more coherent code.

Scaling the Problem: N Models

FastRender used a single model (or model family), but what happens when a swarm queries heterogeneous models?

• Some agents hit GPT-5.2
• Some hit Claude Opus 4.2
• Some hit Llama 4 running locally
• Some hit Mistral Large via API

For factual queries with clear answers (e.g., "What is 2+2?"), model consistency might not be a significant issue. However, for more complex tasks:

• Factual Consistency: Different models might provide different answers to the same question, leading to further divergence.
• Styling and Conventions: Each model has its own style and conventions, which can result in inconsistent code.

Verification as a Solution

The coherence problem is not unique to FastRender. Gensyn’s Verde paper explores whether verification techniques can tame swarm divergence. The idea is to use formal methods and automated testing to ensure that the code produced by AI agents meets specific criteria, even if they diverge in their initial choices.

Conclusion

FastRender’s success demonstrates the potential of AI swarms in rapid development. However, it also highlights the need for robust verification and coordination mechanisms to ensure coherent and reproducible results. As we continue to explore the capabilities of AI swarms, understanding and addressing swarm divergence will be crucial for building reliable and maintainable systems.