✦ Centauri — own your data, your AI, and your gateway.

The software is $0. Forever.

Centauri is open source under The PostgreSQL License — an OSI-approved permissive license that lets you use, copy, modify, and distribute the software for any purpose, including commercial, free of charge and with no copyleft obligations. Copyright JacobLabs LLC and contributors. There is no paid edition: the binary you download is everything.

How that compares

Sources: Kong Konnect, Google Cloud Apigee, and AWS API Gateway public pricing pages — indicative list prices as of mid-2026. Enterprise contracts vary widely; verify with the vendors before budgeting.

Where Centauri fits — and where it doesn't

Centauri is the flight recorder beside your operational stores, not a Postgres replacement. The unvarnished picture, ✗ and all. Coming from Oracle? There is a concept-by-concept teardown — redo/undo, SCN, flashback, RAC, Data Guard mapped to Centauri's internals: Centauri internals vs Oracle →

One engine, the jobs of many databases.

Modern AI stacks bolt together a document store, a vector database, a search cluster, a graph, and an audit ledger — then spend their lives keeping them in sync. Centauri is a single binary that covers all of it, because every fact is stored once with its time, cause, source, and trust. Here's how it maps to the tools you already know — and where it goes further.

The thread that ties it together: Centauri is built for AI agents — a native MCP server means an agent uses all of the above directly, with grounded, point-in-time, provenance-aware memory. One zero-dependency binary you run yourself — not five systems to license, host, and reconcile. It's the system of record beside your operational database, not a replacement for it.

Let an AI see your files — locally, for free.

Drop in an image or a PDF — an electrical drawing, a scanned form, a photo. A vision model running on your machine reads it; Centauri stores the file (content-addressed, on disk — never in the log), the model's structured description, and a vector embedding — all as facts you can query. No Firestore, no object store, no API bill, nothing leaving your computer. Centauri even installs and runs the model for you.

The loop: Upload → ENRICH → SEARCH / ASK. Your electrical drawings, contracts, and photos become searchable by what's in them — the kind of thing teams normally wire up Firestore, an object store, and a cloud vision API to do. Here it's one local binary. Setup: vision-setup.md · features: ai-features.md.

How an agent actually uses Centauri.

Centauri exposes a native MCP server with 20 typed tools, so an agent calls the database directly — no string-building, no SQL injection, no glue. Here's a real interaction.

// humans write CeQL text…
FACTS OF item:100001/store:4001 AS OF '2026-03-15' WHY

// …agents emit the same query as a typed JSON AST —
// no parsing, no injection, just a tool call:
{ "kind":"facts", "subject":"item:100001/store:4001",
  "as_of": 1742000000000000, "why": true }

// embed the user's question as an event, then blend
// keyword (BM25) + vector recall in one call:
SEARCH 'late markdown register' OF item:*
  SIMILAR TO evt:user_question ALPHA 0.5

// top hits become grounded context for the model

# Python SDK — features exactly as known then,
# so the model can't peek at the future:
row = db.context("item:100001/store:4001",
                 known_at="2026-03-01")
# no label leakage, no train/serve skew

centauri_ceql("PENDING pdt OLDER THAN 21 DAYS")
centauri_asof({subject, at, known_at})  // decision replay
centauri_trace({event, direction:"cause"}) // WHY
centauri_genesis({scenario})        // build a DB

# expose ONE tool that POSTs CeQL — works with any model
curl -s localhost:7771/v1/query \
  -H 'Authorization: Bearer TOKEN' \
  -d '{"q":"FACTS OF item:100001/store:4001 WHY"}'

# pip install google-generativeai requests
import google.generativeai as genai, requests
def centauri_query(ceql: str) -> str:
    """Run a CeQL query against Centauri and return JSON."""
    return requests.post("http://localhost:7771/v1/query",
        headers={"Authorization": "Bearer TOKEN"},
        json={"q": ceql}).text
m = genai.GenerativeModel("gemini-2.0-pro", tools=[centauri_query])
chat = m.start_chat(enable_automatic_function_calling=True)
print(chat.send_message(
  "What did item:100001/store:4001 cost on 2026-03-01?").text)
# Gemini auto-calls centauri_query(ceql) and grounds its answer.

# same centauri_query() as above; register it as a tool
tools=[{"type":"function","function":{
  "name":"centauri_query",
  "parameters":{"type":"object",
    "properties":{"ceql":{"type":"string"}}}}}]
OpenAI().chat.completions.create(model="gpt-4o", tools=tools, messages=[...])
# then dispatch the tool call to centauri_query(args["ceql"])

# Claude speaks MCP natively — just add this to the config:
{ "mcpServers": {
    "centauri": { "command": "centauri", "args": ["mcp"] }
} }
# Claude Desktop/Code now has all 20 Centauri tools. No code.

from openai import OpenAI
client = OpenAI(api_key="XAI_KEY",
                base_url="https://api.x.ai/v1")  # model "grok-2"
# same centauri_query tool. Identical pattern works for
# Mistral, Together, Groq, Fireworks, OpenRouter, DeepSeek…

from openai import OpenAI
client = OpenAI(base_url="http://localhost:11434/v1",  # Ollama
                api_key="ollama")                       # model "llama3.1"
# same centauri_query tool — fully offline & private.
# LM Studio → :1234/v1 · vLLM → :8000/v1 · llama.cpp → :8080/v1

All 20 MCP tools are documented in The CeQL Book · the JSON AST is the same shape CeQL parses to, so anything you can type, an agent can emit.

One binary. A lot of database.

No extensions to install, no services to wire up — everything below ships inside a single executable with zero third-party dependencies.

CeQL reference

One query language for time, cause, trust, shape, and meaning. Every statement below is documented in full — with a Rosetta Stone from SQL, Cypher, Mongo and more — in The CeQL Book.

Beyond the language, the single binary ships a Studio IDE (object explorer, editor, causal-graph view, inline edit-as-a-fact), a psql-style centauri shell, EXPLAIN ANALYZE, CDC with resumable replication slots, and scoped tokens (subject-prefix row-level security) — all detailed in The CeQL Book.

Get data in and out — without lock-in.

Centauri is the system of record beside your operational stores, so moving data across the boundary is first-class. Two open paths: native Airbyte connectors and a resumable change stream.

The connectors are standalone (pure-stdlib Python, no Airbyte CDK) and never link into the single binary — the zero-dependency core is untouched. Connector source & quickstart →

The same operators, everywhere.

Centauri isn't a retail tool — the subjects are just names. Here's how each capability reads in healthcare, finance, security, ML, IoT, and more. Every query is real CeQL.

-- decision replay: the chart as it was that day
CONTEXT FOR patient:8842/encounter:0421
  AS KNOWN AT '2026-02-10'

-- regulators ask "what did you know, and when?"
FACTS OF position:*/desk:fx
  AS OF '2026-03-15 16:00 EST'
  AS KNOWN AT '2026-03-15 16:00 EST'

-- walk the causal graph to the root
FACTS OF incident:5521 WHY DEPTH 6

-- forward blast radius from one event
EFFECTS event:cred-leak-77 DEPTH 8

-- ranked full-text, not substring
SEARCH 'tls handshake timeout' OF incident:*

-- BM25 recall + vector semantics in one call
SEARCH 'pod crashloop oom' OF runbook:*
  SIMILAR TO evt:user_question ALPHA 0.5

-- persistent homology finds the loop a
-- threshold rule would miss
SHAPE OF transfer:* ON amount, velocity

-- a void (Betti-2) = a coverage gap
SHAPE OF sensor:* ON lat, lon, range MAXDIM 2

-- a clean loop = regular rhythm; a broken
-- one flags arrhythmia (time-delay embedding)
SHAPE OF signal:ecg/patient:8842 ON mv WINDOW 40

-- topological drift across time buckets
DRIFT OF feature:churn_v3/* ON value BUCKETS 8

-- which system is the outlier, by how much
CONSISTENCY OF patient:8842/lab:potassium
  ON value EPS 0.2

-- a directed cycle in the money graph
CYCLES IN CAUSES OF transfer:*

-- the silent rollout that never landed
PENDING host OLDER THAN 2 DAYS
DISAGREE ON config_hash

# recomputes the SHA-256 chain byte-for-byte
$ centauri verify
chain head: 7f3a… · 1,284,902 records · intact ✓