Fracta: A Swarm Intelligence Engine

Fracta is the system materialization of the explore/exploit pattern for AI agents.

Reasoning loops are inherently non-deterministic, as sampling, context, and model versions naturally drift. Fracta bridges the gap between open-ended AI reasoning and rigid, reproducible analytics by splitting the workload into exploration (agents discovering context) and exploitation (strategies running deterministic logic on those discoveries).

How It Works

Your machine runs the AI CLI you already use. Everything else — the control plane, the MCP gateway, the strategy runner, the knowledge graph, and the agents themselves — runs server-side, whether "server" means a local process, a Docker Compose stack, or a Kubernetes cluster.

Reading the diagram in explore/exploit terms: the agents on the right are the explore loop, reasoning over MCP tools and writing what they find into the knowledge graph. The strategy runner is the exploit loop, reading the graph and staged data and returning deterministic results that the agents (or you) can act on without re-reasoning.

flowchart LR
    classDef client fill:#475569,stroke:#1e293b,color:#fff,stroke-width:1.5px
    classDef cp fill:#3A4ACC,stroke:#1e2b8a,color:#fff,stroke-width:2px
    classDef gw fill:#5B6CFF,stroke:#3A4ACC,color:#fff,stroke-width:2px
    classDef sidecar fill:#8BA0FF,stroke:#5B6CFF,color:#0b1437,stroke-width:1.5px
    classDef store fill:#b45309,stroke:#7c2d12,color:#fff,stroke-width:1.5px
    classDef agent fill:#059669,stroke:#065f46,color:#fff,stroke-width:1.5px

    subgraph user["Your machine"]
        CLI["Claude / Codex / OpenCode"]:::client
        SERVE["fracta serve<br/>(thin MCP client)"]:::client
        SPAWN["fracta spawn / list / say (CLI)"]:::client
        CLI -->|stdio| SERVE
    end

    subgraph server["fracta server-side (local · docker-compose · k8s)"]
        CP["Control Plane :9090<br/>spawn · kill · queue · lifecycle"]:::cp
        GW["MCP Gateway :8080<br/>tools · graph · strategies"]:::gw
        SR["Strategy Runner<br/>(python sidecar)"]:::sidecar
        SS[("State Store")]:::store
        KG[("Knowledge Graph<br/>FalkorDB")]:::store
        REG[("MCP Registry")]:::store
        AGENT["Agent<br/>(subprocess or pod)"]:::agent
        CP --> SS
        GW --> KG
        GW --> REG
        GW <--> SR
        CP -->|spawns| AGENT
        AGENT -->|MCP tools| GW
    end

    SERVE -->|HTTP| CP
    SPAWN -->|HTTP| CP

The thin client (fracta serve) is always the same. Only the infrastructure behind the control plane changes — see Architecture for the full breakdown.

Core Architecture

Fracta is built on four main pillars that operate over a shared trust boundary:

• 🎛️ Control Plane & The Chessmaster (Swarm Orchestration) Manages the lifecycle and orchestration of the agent swarm. At its core is the Chessmaster, the central orchestrator that spawns agent workers and assigns each a specific mission (an explicit objective they need to achieve). It facilitates parallel reasoning, concurrent execution, and unattended operations across the entire system.

• 🤖 The "Explore" Phase: Agents Agents act as the workers handling open-ended investigation, contextual reasoning, and deciding what to explore next to fulfill their missions. To collaborate effectively, agents communicate with each other and the Chessmaster via a robust internal mailbox system, utilizing inbox (direct messaging), intention (signaling planned actions), and broadcast (swarm-wide updates) mechanics. Fracta is agnostic to the agent runtime (you can use whatever AI CLI you already rely on, such as Claude Code, Codex, or OpenCode).

• ⚙️ The "Exploit" Phase: Strategies (Deterministic Execution) Strategies are deterministic Python pipelines that encode reproducible analytics on top of what the swarm has discovered. Crucially, these strategies are created directly based on the results of the exploration phase. At this point, humans need to intentionally create and refine these strategies iteratively based on exploration results, using their agentic coding CLI of choice. In the future, Fracta workers will be able to automatically suggest or derive strategies directly from recurring exploration patterns. This is how you run fast, millisecond-level operations (counts, joins, correlations, sliding windows, map-reduce, detection rules) with zero LLM in the loop.

• 🔌 MCP Gateway (Tool Registration & Concurrency) A native Model Context Protocol (MCP) server that manages tool registration and natively handles high-concurrency connections. It exposes the exact same tool catalog across two distinct client modes:

  • Agentic Calling: Agents driving tools via an LLM.
  • Non-Agentic Calling: Strategies driving tools through deterministic Python.
  • Unified Concurrency: Parallelism is persistent and native. The gateway seamlessly manages concurrent execution, whether that is a swarm of agents exploring independently, five deterministic strategies executing at the exact same time, or multiple client modes operating simultaneously (all securely sharing the same tools and trust boundary).

• 🗺️ Knowledge Graph & Ontologies The shared world model capturing the swarm's state. It goes beyond simple memory by carrying strict ontologies, which define valid entity types, relationships, and dynamics. Ontologies are seeded upfront and extended at runtime as agents discover new shapes, providing concrete structural guarantees that Strategies can reliably query against.

Example: a 3-agent swarm

The pillars above describe the system at rest. Here's an interaction trace of three agents running a recon → enrich → report pipeline against the swarm — spawned in parallel, each calling MCP tools through the gateway, coordinating peer-to-peer via inbox/broadcast messages, reporting status back to the control plane, and reaped together when the mission completes:

여기까지가 README 앞부분입니다. 나머지는 원문에서 읽을 수 있습니다. README 전문 보기 ↗