Introducing DreamSwarm v0.9

The best way to orchestrate autonomous AI agents.

DreamSwarm coordinates planners, researchers, builders, and critics across multi-repo mega-workspaces. Deploy swarms with guardrails, full observability, and zero configuration.

Give us a star View roadmap →

DreamSwarm

1use dreamswarm::{Swarm, TeamConfig, Agent};
2use dreamswarm::providers::Claude;
3
4// Configure your swarm mission
5let config = TeamConfig {
6    strategy: SpawnStrategy::GitWorktree,
7    max_workers: 4,
8    linked_repositories: vec![
9        "/path/to/frontend".into(),
10    ],
11};
12
13// Spawn a parallel swarm
14let swarm = Swarm::new(config, Claude::Sonnet);
15swarm.run("Implement OAuth2 login flow").await?;
16
17// Results stream in real-time
18while let Some(event) = swarm.next().await {
19    println!("[{}] {}", event.agent, event.msg);
20}

The Philosophy

Built by AI engineers,
for AI engineers.

We are builders who needed an autonomous orchestration layer that didn't require choosing between power and predictability. DreamSwarm is the open platform we always wished existed — persistent, self-healing, and fully observable.

DreamSwarm — conflict detection

$ dreamswarm daemon start
===== KAIROS Daemon v0.9 =====
✓ FileWatcher active on 3 branches
✓ Evolution Coordinator armed
⚠ Conflict predicted: src/auth.rs
  Branches: [feature/oauth, fix/tokens]
→ Writing DREAMSWARM_CONFLICT_WARNING.txt
= 1 conflict predicted, 0 merges blocked =

DreamSwarm — evolution cycle

1use dreamswarm::evolution::EvolutionCoordinator;
2
3// Neural evolution runs autonomously
4let evo = EvolutionCoordinator::new(db);
5evo.run_cycle_if_due().await?;
6
7// Generates challenger prompt variants
8// Tracks lineage & scores in SQLite
9// Replaces underperformers autonomously

Capabilities

Everything a swarm needs
to operate autonomously.

🧠

3-Layer Memory

L1 index always in context. L2 topic files loaded JIT via vector search. L3 transcripts archived for autoDream consolidation.

⚡

KAIROS Daemon

A background Tokio-powered heartbeat that monitors git activity, detects engineering debt, and dispatches tasks proactively.

🐝

Parallel Swarms

Multiple specialized agents work simultaneously on isolated git worktrees, communicating via async mailboxes.

🔗

Multi-Repo Workspaces

Link multiple repositories into a single mega-workspace. Agents have full context across your entire codebase.

🧬

Neural Evolution

EvolutionCoordinator autonomously generates challenger prompt variants and promotes winners based on telemetry.

📡

The Oracle API

Full REST + SSE API for real-time telemetry, hive control, and remote stop/dream/war-room commands.

🔒

5-Layer Security Gate

Every tool call passes Mode check → Deny list → Allow list → Risk scoring → Human approval. Immutable JSONL audit logs throughout.

🔍

Vector Semantic Search

fastembed-powered local embeddings let agents retrieve the most relevant L2 memory topics without ever leaving your machine.

🖥️

TUI Dashboard

A live terminal dashboard shows every active agent, tool call, trust score, and memory health in real time — no browser required.

KAIROS Daemon

A heartbeat that never stops.

KAIROS (Kinetic AI Real-time Operational System) is a persistent Tokio-powered daemon that monitors your workspace 24/7. When it detects a missing test, an anti-pattern, or a predicted merge conflict, it acts — with trust-gated autonomy.

As KAIROS proves its competence, it graduates from AskFirst → AutoAct — handling low-risk improvements without interrupting your flow.

DreamSwarm — oracle API

GET  /consensus
{ "status": "Oracle Online",
  "trust_index": 0.92,
  "layer_3_health": "Optimal" }
GET  /api/v1/telemetry/stream  ← SSE
data: {"agent":"worker-1","action":"edit"}
data: {"agent":"worker-2","action":"test"}
POST /api/v1/control/war-room
⚠  Cascading failure simulation active
✓  100Hz telemetry flood: stable
POST /api/v1/control/stop
{ "status": "Stop signal broadcasted" }

Security

Five gates stand between intent and execution.

DreamSwarm operates on a Security-First foundation. Every autonomous tool call — bash, file write, git push — traverses a 5-layer permission gate before it executes.

Every action is signed and persisted in an immutable JSONL audit log. Memory consolidation runs in sandboxed buffers that never touch source files directly.

Mode Check

Is the agent operating in AskFirst or AutoAct mode? Different trust levels unlock different capability ceilings.

Deny List

Blocked command patterns (e.g. rm -rf /, curl to internal metadata) are rejected before evaluation.

Allow List

Pre-approved scripts and tools bypass risk scoring for known-safe operations.

Risk Scoring

Semantic analysis of the command determines impact surface — does this touch critical infra or production config?

Human Approval

The final human-in-the-loop gate. High-risk actions are always paused for explicit user confirmation.

Tool Ecosystem

15+ built-in tools.
Zero configuration.

Every tool in the registry is sandboxed, permission-gated, and observable. Agents compose them to solve real engineering problems autonomously.

⚙️

bash_tool

Shell command execution

📝

file_write

Atomic file mutations

📖

file_read

Contextual file loading

🔎

grep_tool

Semantic code search

🐍

python_tool

Inline Python evaluation

🌐

js_tool

Node.js script runner

🦀

rust_debug

Cargo test + clippy

🔀

git

Full git operations

🧠

memory_tools

L1/L2/L3 read & write

🐝

swarm_tools

Agent spawn & mailbox

💤

dream_trigger

Manual autoDream cycle

📊

monitor_tool

Live swarm telemetry

🧩

synthesis

Multi-source synthesis

🔔

push_notification

Async agent alerts

❓

ask_user

Human-in-the-loop gate

📡

daemon_status

KAIROS health check

Roadmap

14-phase architecture.
13 shipped, 1 in progress.

Phase 1–4

Core Loop, Memory & Tools

Agent reasoning loop, 3-layer memory, tool plugin system, session persistence

✓ Done

Phase 5

Swarm Coordinator

Multi-agent spawning with worktree isolation and async mailbox communication

✓ Done

Phase 6

The Oracle REST API

Axum-powered HTTP + SSE API for telemetry, control signals, and hive state

✓ Done

Phase 7–9

Resilience & Self-Healing

Warm-start from CHECKPOINT.json, trust-based autonomy, proactive self-correction

✓ Done

Phase 10–11

Control Signals & Multi-Repo

War Room stress testing, mega-workspace orchestration across linked repositories

✓ Done

Phase 12

Neural Evolution

Autonomous prompt optimization, challenger generation, and lineage tracking in SQLite

✓ Done

Phase 13

P2P HiveMind Consensus

Distributed multi-node agent mesh with Raft-inspired coordination

In Progress

Phase 14

Predictive Conflict Resolution

Pre-emptive merge conflict detection via FileWatcher branch diffing

✓ Done

The best way to orchestrate autonomous AI agents.

Built by AI engineers,for AI engineers.

Everything a swarm needsto operate autonomously.

A heartbeat that never stops.

Five gates stand between intent and execution.

15+ built-in tools.Zero configuration.

14-phase architecture.13 shipped, 1 in progress.

Start orchestratingyour dream team.

Built by AI engineers,
for AI engineers.

Everything a swarm needs
to operate autonomously.

15+ built-in tools.
Zero configuration.

14-phase architecture.
13 shipped, 1 in progress.

Start orchestrating
your dream team.