The Collaborative Intelligence Fabric for Distributed Problem-Solving

EnsembleOS is not another workflow tool or automation script. It is a lightweight, swarm-inspired orchestration layer that enables any collection of agents, microservices, or human decision-makers to operate as a unified cognitive system. Think of it as a shared nervous system for your distributed processes—where each participant contributes partial knowledge, and the whole emerges smarter than any part.

Inspired by the elegant inefficiency of biological swarms (ant colonies, bee hives, neural networks), EnsembleOS replaces rigid pipelines with a fluid consensus topology. It is designed to run on commodity hardware, cloud functions, or even embedded devices. No centralized coordinator required. No single point of failure. Just patterns, votes, and emergent order.

Most systems today force a central authority to decide what happens next. This creates bottlenecks, single points of failure, and brittle architectures. EnsembleOS flips the model: every participant proposes, every participant votes, and the system converges on the most coherent path forward. This is not democracy—it is distributed intelligence emergence.

The result? Systems that adapt to failure, learn from partial data, and scale horizontally without coordination overhead. You get resilience by design, not by redundancy.

Participants communicate through a lightweight opinion-propagation mechanism. Each node shares its local belief state, weighted by credibility. The network converges on a shared representation without needing a global view. This means no single node ever holds the full picture, yet the collective acts as if it does.

Designed for real-time environments. Typical convergence happens in under 300 milliseconds for swarms of up to 1,000 participants on standard cloud instances. For edge deployments, we provide adaptive quorum thresholds that trade speed for certainty.

The protocol itself is language-agnostic. We provide reference clients in Python, Rust, Go, and TypeScript. The wire format is Cap'n Proto—compact, zero-copy deserialization, with schema evolution built in. You communicate in your language; the swarm understands all.

Extend EnsembleOS with cognitive modules that run inside any participant. Need sentiment analysis? Load the AffectMirror plugin. Need temporal forecasting? Attach the ChronoStitcher module. Each plugin is a self-contained function that transforms local beliefs before propagation. No code changes to the core—just drop in a .wasm module.

If a participant disappears, the swarm automatically redistributes its responsibility across remaining nodes. This happens without reconfiguration. The system re-forms connections using a gossip-based peer discovery that tolerates churn rates up to 40% per minute.

Watch the swarm think. The EnsembleOS Observer provides a live, real-time visualization of belief propagation, consensus formation, and participant credibility. Useful for debugging, auditing, or just appreciating the beauty of distributed intelligence.

[Participant A] <--gossip--> [Participant B] <--gossip--> [Participant C]
      |                            |                            |
[Plugin: Vision]          [Plugin: Language]          [Plugin: Memory]
      |                            |                            |
      +------------------+---------+---------+------------------+
                         |                   |
                [Credibility Weight]   [Consensus Anchor]
                         |                   |
                    [Ensemble Decision] --> Output

Every participant stores a local belief matrix (a vector of floating-point weights). After each round of gossip, they update this matrix using a modified belief propagation algorithm (loopy BP with damping). The process repeats until the entropy of the system falls below a configurable threshold. At that point, the Consensus Anchor (a rotating role) broadcasts the final state.

No central database. No master node. Just iterative agreement.

Multiple manufacturers, logistics providers, and retailers each hold partial data. EnsembleOS lets them coordinate delivery schedules without sharing sensitive details. Each participant contributes a belief about optimal timing; the swarm converges on a shared plan that respects everyone's constraints.

Distributed teams analyzing the same dataset (e.g., genomics, climate models) can use EnsembleOS to merge partial insights into a unified hypothesis. Each team runs its own analysis; EnsembleOS synthesizes the results into a consensus prediction with uncertainty bounds.

Deploy multiple LLM agents, each with a different persona or knowledge base. EnsembleOS lets them debate, refine, and converge on the best response to a user query. The final output is not a single model's guess—it is the emergent agreement of a diverse panel of synthetic minds.

IoT sensors with constrained compute resources can form a local swarm to detect anomalies. Instead of sending all data to the cloud, they process locally and share only belief states. EnsembleOS ensures that a failing sensor does not corrupt the collective decision.

• A runtime environment with any of: Python 3.10+, Rust 1.70+, Go 1.21+, or Node.js 18+
• Network access between participants (can be localhost, LAN, or internet with UDP hole-punching)
• 64 MB of free RAM per participant (minimum)

1. Initialize a swarm with three participants on your local machine:

   # Terminal 1
   ensembled --port 9001 --name node-alpha
   
   # Terminal 2
   ensembled --port 9002 --name node-beta --bootstrap localhost:9001
   
   # Terminal 3
   ensembled --port 9003 --name node-gamma --bootstrap localhost:9001
   

2. Inject a problem from the CLI:

   ensemble-cli inject --problem "Which route has the lowest latency?" --data '{"source": "NYC", "dest": "LAX"}'
   

3. Watch convergence in real-time via the dashboard (default at localhost:8080).

4. Read the decision:

   ensemble-cli latest-decision
   # Output: {"route": "I-80", "confidence": 0.87, "participants": 3}
   

That is the whole flow. No API key, no cloud dependency, no signup. Just distributed intelligence, locally.

Plugins are WebAssembly modules with a single exported function: process(local_beliefs: Vec<f32>, message: &[u8]) -> Vec<f32>. The function receives the current belief vector and any incoming message, and returns an updated belief vector.

Example in Rust:

#[no_mangle]
pub extern "C" fn process(beliefs: *mut f32, len: usize, msg_ptr: *const u8, msg_len: usize) -> *mut f32 {
    // ... transform beliefs based on message ...
}

Compile to .wasm, drop it in the plugin directory, and the node automatically loads it on restart.

Tested on a cluster of c6i.4xlarge instances (AWS, 16 vCPUs, 32 GB RAM each):

The algorithm scales O(n log n) in convergence time due to the gossip topology's logarithmic diameter. Memory scales O(n) because each node stores a belief vector proportional to swarm size.

EnsembleOS assumes a semi-honest adversary model. Participants follow the protocol but may observe messages. For sensitive applications, we provide:

• End-to-end encryption of belief vectors using XChaCha20-Poly1305
• Credibility decay for participants that frequently disagree with the consensus
• Anomaly detection plugins that flag participants with statistically improbable behavior

For zero-trust environments, deploy EnsembleOS inside a TEE (Trusted Execution Environment) using Intel SGX or AMD SEV. The belief propagation still works; the hardware just protects the memory.

We welcome contributions that improve the core protocol or add domain-specific plugins. Before submitting a pull request:

1. Read the design philosophy document (in docs/philosophy.md)—the most important rule is "no centralized authority, ever."
2. Run the consensus simulation suite: cargo test --test consensus_rules
3. Ensure your plugin compiles to .wasm and passes the plugin sandbox checker.

See CONTRIBUTING.md for the full process, code of conduct, and style guide.

This project is licensed under the MIT License. You are free to use, modify, and distribute it, even in commercial products. The only requirement: preserve the copyright notice in any distribution.

View the full license text

EnsembleOS is a research-grade distributed consensus system. While it has been tested across thousands of simulated scenarios, emergent behavior in production systems may differ from lab conditions. The authors are not liable for any decisions made by the swarm, including but not limited to resource allocation, routing choices, or automated actions triggered by consensus output.

Always validate critical decisions through independent means before acting on them. EnsembleOS is a tool for augmentation, not delegation of responsibility.

• Documentation: Full API reference, protocol specification, and plugin SDK docs available in the docs/ directory.
• Community Forum: Discussions about swarm intelligence, use cases, and plugin development (link in repository sidebar).
• Enterprise Support: For organizations needing SLA-backed deployments, custom plugin development, or integration consulting, contact the maintainers via the repository's issue tracker with the label pro-support.

The name comes from musical ensemble—a group of musicians who listen to each other, adjust in real-time, and create something greater than any solo performance. EnsembleOS does the same for distributed systems. It is not an operating system in the traditional sense; it is an operating system for collective intelligence.

Every participant is a voice. Every voice matters. Together, they find harmony.