Agentic Swarms should become Infrastructure.
Orchestrate AI agent swarms. Codify what they discover.
Fracta turns open-ended agent exploration into high-performance, deterministic automation. Agents explore. Strategies exploit. One shared knowledge graph, one unified tool layer, zero token waste on the routine work.
Today's agent stacks quietly cap how far you can take a workflow before it breaks down. Fracta is built around fixing each of these in turn.
The same task re-runs through an LLM every time. Tokens burn, outputs drift, and the “happy path” you found yesterday is never quite reproducible tomorrow.
A strategy is a pure Python DAG that calls MCP tools straight through the gateway. The LLM is out of the loop, so the run is deterministic, millisecond-fast, and costs zero tokens.
Each agent wires up its own MCP servers, credentials, and rate limits. There's no single place to enforce policy, audit calls, or share connections.
The MCP Gateway owns every tool, every credential, every rate limit. One trust boundary, one allow-list, one audit log — shared across agents and strategies alike.
Today's options stop at a single laptop. You can run a serial chain or fan out a few parallel processes — but each subagent is isolated with no protocol to coordinate or share state, and there's no path to spawn thousands of agents unattended in the cloud, the way real infrastructure runs.
The Control Plane spawns and reaps agents unattended as subprocesses, containers, or k8s pods — from three on a laptop to thousands in the cloud, agent-agnostic by default. A mailbox protocol (inbox, intention, broadcast) lets them coordinate peer-to-peer at any scale.
Your AI CLI runs locally. Everything else — control plane, MCP gateway, strategy runner, knowledge graph, agents — lives server-side. The same architecture runs as a local process, a Docker Compose stack, or a Kubernetes cluster.
Fracta doesn't care which model is running — Claude, Codex, OpenCode. It provides the shared infrastructure: messaging, graph, strategies, and a unified tool gateway.
Spawn hundreds or thousands of concurrent agent pods, each in its own isolated workspace. Coordinate via mailbox messages and a shared world model — peer-to-peer, without stepping on each other.
Agents handle open-ended discovery and reasoning. Strategies encode the deterministic logic in pure Python DAGs — runs in milliseconds, reproducible, zero LLM tokens for the routine work.
Shared FalkorDB world model captures what agents discover under strict, extensible ontologies. Strategies query with confidence. The swarm builds context that survives sessions.
A strategy is three files: a contract.yaml declaring the data
it needs, a strategy.py with the DAG, and a binding.yaml
mapping the contract to your environment. Share the first two; each
team writes its own binding.
name: "splunk-field-survey"
version: "1.0.0"
description: >
Survey Splunk indexes and sourcetype fields
for knowledge graph enrichment.
tags: [enrichment, splunk]
params:
index_pattern:
type: str
default: "*"
requires:
tables:
splunk_fields:
columns:
index: type: VARCHAR
sourcetype: type: VARCHAR
field_name: type: VARCHAR
discovery:
mcp_hints:
- tool: "splunk.list_fields"
stage_as: "splunk_fields"contract: "splunk-field-survey@1.0.0"
backend: splunk
credentials: env:SPLUNK_TOKEN
endpoint: "https://splunk.corp.local:8089"
tables:
splunk_fields:
source: "splunk.list_fields"
params:
index: "main,security_*,zeek_*"
earliest: "-7d@d"
cache:
ttl: 3600
parquet: ".fracta/stage/splunk_fields.parquet"A native Model Context Protocol gateway manages tool registration and high-concurrency connections. Agents drive it via LLM; strategies drive it deterministically. One credential store, one allow-list, one place to audit.
# spawn three agents on the same mission
$ fracta spawn task=recon --swarm threat-hunt
$ fracta spawn task=enrich --swarm threat-hunt
$ fracta spawn task=report --swarm threat-hunt
# peek at semantic output without disrupting
$ fracta peek task=recon
# run a deterministic strategy on staged data
$ fracta strategy run event_correlation \
--window 24h --graph mission/threat-hunt
# reap the swarm when the mission completes
$ fracta kill --swarm threat-huntThe thin client on your machine stays the same. The control plane, gateway, and state stores adapt to the substrate you choose.
Single machine. Binary plus embedded SQLite and FalkorDB. Best for development and small swarms.
Containerised stack with the same architecture as production. Great for staging and team demos.
Agent pods plus stateful backends. Scales to thousands of concurrent agents in production.
Run parallel investigations across logs, alerts, and identity systems. Codify repeatable detections as strategies.
Mix open-ended LLM exploration with reproducible analytics over the same captured world model.
Run many related changes in parallel — refactors across packages, dependency upgrades — backed by deterministic checks.
Multi-hour or multi-day agent workflows where the swarm thinks and strategies do the reproducible heavy lifting.
Clone the repo, build the binary, scaffold a project, and spawn your first agent. The docs walk you through every step.
FSL-1.1-ALv2 · free for internal use · converts to Apache 2.0 two years after each release