v0.1.0 — initial public release

Trace intent. Debug causality.

The first content-addressable ledger for AI agents. Every prompt, model, read, write and reasoning becomes an immutable causal event — queryable like git, but for the intent behind every line of code.

Quick start View on GitHub

BSL 1.1 → Apache 2.0 · Linux · macOS · Windows · ~3 MB binary · No telemetry

~/your-app — re

R to replay · Real re CLI output

The problem

Your agents are writing rewriting your codebase. Blind.

Black box edits

Cursor touched 30 files in 4 minutes. Which prompt wrote that suspicious regex on line 84? You don't know. Nobody does.

Silent regressions

You revert one of yesterday's agent changes. Three other agent decisions silently lose the context they were built on. CI is green. Production isn't.

Causal amnesia

A test breaks 200 prompts later. Bisect through chat logs? You read for an hour, give up, and rewrite the feature from scratch.

The thesis

Git tracks bytes. LangSmith tracks conversations. IDE checkpoints track snapshots.
None of them connect a line of code to the intent that produced it.
Causari does. We call it intent-addressable code.

What you get

A complete causal layer for agentic codebases.

15+ commands. One binary. Zero cloud. Built in Rust, content-addressed with BLAKE3, queryable in microseconds.

Bidirectional causal graph

re trace walks upstream — every event that contributed to a line, transitively. re impact walks downstream — every event that depended on a change. The full blast radius, before you click revert.

Built-in MCP server

One flag — re mcp — and Claude Desktop, Cursor, Cline and Windsurf can read and write the ledger. Tools: causari_record, causari_recall, causari_why.

Time-travel debugging

Restore the full workspace to the state before any event in the timeline. Combine with re bisect --test to binary-search the agent action that broke the build.

Provenance lens

re lens src/auth.ts renders the file with per-line attribution — agent, model, prompt, snippet — like git blame, but for intent. The first hour of onboarding any AI-touched codebase, solved.

Causality-aware revert

Revert isn't free. Causari shows you the downstream events that would lose their context, then asks. No more silent regressions hidden in three layers of agent reasoning.

Local-first, no cloud

Everything lives in .causari/ next to your code. BLAKE3 content-addressed. Your prompts, models and reasoning never leave your machine. No telemetry. No accounts. Ever.

Versus the world

The category nobody else is building.

There are great tools for source control, observability, and agent monitoring. None of them sit at the intersection where AI codebases actually break.

Capability	git	LangSmith	IDE checkpoints	Causari
Tracks code	✓	✗	✓	✓
Tracks the prompt	✗	✓	✗	✓
Tracks the model	✗	✓	✗	✓
Tracks reads (context)	✗	partial	✗	✓
Causal graph (upstream)	✗	✗	✗	✓
Causal graph (downstream)	✗	✗	✗	✓
Per-line provenance lens	blame	✗	✗	✓
Bisect on any predicate	✓	✗	✗	✓
MCP server (universal agents)	✗	✗	✗	✓
Local-first, no cloud	✓	✗	depends	✓
Open source	✓	SDK only	depends	BSL 1.1

MCP integration

One config snippet. Every agent runtime.

Causari speaks Model Context Protocol natively. Drop the snippet into your agent's settings and Causari shows up as three callable tools — causari_record, causari_recall, causari_why.

Add to ~/Library/Application Support/Claude/claude_desktop_config.json (macOS) or %APPDATA%/Claude/claude_desktop_config.json (Windows).

{
  "mcpServers": {
    "causari": {
      "command": "re",
      "args": ["mcp"],
      "cwd": "/absolute/path/to/your/project"
    }
  }
}

Run once in your project directory:

claude mcp add causari -- re mcp

Add to .cursor/mcp.json in your project (or in ~/.cursor/mcp.json globally).

{
  "mcpServers": {
    "causari": { "command": "re", "args": ["mcp"] }
  }
}

Same config shape as Cursor — Windsurf surfaces the tools automatically.

{
  "mcpServers": {
    "causari": { "command": "re", "args": ["mcp"] }
  }
}

Add to VS Code's cline_mcp_settings.json.

{
  "mcpServers": {
    "causari": { "command": "re", "args": ["mcp"] }
  }
}

Tip: have the agent call causari_record after every tool call. Causari builds a complete, queryable history of the session for you, automatically.

Code gallery

Real commands. Real output.

No mockups. This is the actual re CLI on a real session.

why

Who wrote this exact line?

$ re why src/auth.ts:42

src/auth.ts:42  →  introduced by event a3f7b2c9
  agent:    claude-3.5-sonnet
  prompt:   "Add JWT refresh logic that rotates every 24h"
  reads:    spec/auth.md, package.json
  writes:   src/auth.ts (lines 38-52)
  reasoning:
    The spec calls for refresh tokens with a 24h expiry.
    I extracted the verify() helper to keep the rotation
    logic testable in isolation.

trace

The full intellectual ancestry of a line.

$ re trace src/calc.ts:7

upstream causal cone of src/calc.ts:7 → 4 events:

├─ a1b2c3d4  align calc with new spec
│  agent: gpt-4o · prompt: "the spec changed, update calc"
│  because: writes calc.ts which is line 7's last edit
│
├─ 99f0c961  redefine sum to be a-b
│  agent: gpt-4o · prompt: "team decided sum = a-b"
│  because: edits spec.md that a1b2c3d4 read
│
└─ 6d698c97  create initial spec
   agent: human · prompt: "draft spec.md"
   because: created spec.md, the seed

impact

What flows downstream from this change?

$ re impact a1b2c3d4

downstream causal cone (blast radius): 3 events depend on a1b2c3d4

  ↓ 5fe6f47e  align tests with new calc
    reads:  src/calc.ts (your event's output)

  ↓ 31bed399  add benchmarks for sum/diff
    reads:  src/calc.ts (your event's output)

  ↓ 0b5ae15e  README: document calc API
    reads:  src/calc.ts (your event's output)

→ reverting a1b2c3d4 will silently invalidate the reasoning of 3 later events.

bisect

Find the agent action that broke the test.

$ re bisect --good 439c5c19 --bad dbc483f9 --test "node test.js"

causari: bisecting 7 events between 439c5c19 (good) and dbc483f9 (bad)

  → step 1 — testing dbc483f9   FAIL
  → step 2 — testing 17cbc28d   FAIL
  → step 3 — testing 88ec0712   OK

found: first bad event: 17cbc28d
  agent:   gpt-4o
  prompt:  "refactor sum to be more elegant"
  tool:    edit_file

Quick start

30 seconds to your first causal event.

1
Install

From source, with the latest Rust toolchain:
```
cargo install --git https://github.com/croviatrust/causari
```
Pre-built binaries land at the next release. Until then, builds take ~45s on a modern laptop.
2
Initialize

Inside any project (Rust, JS, Python — Causari is language-agnostic):
```
re init
```
3
Wire your agent

Either drop the MCP snippet into Claude / Cursor / Cline / Windsurf, or simply run a passive recorder:
```
re watch --agent claude-3.5
```
Now any tool that touches the workspace is recorded. Zero integration.

Ask anything

re log
re why src/auth.ts:42
re trace src/calc.ts:7
re impact <event-id>
re bisect --test "npm test"

License & fairness

Free for production. Forever.

Causari is licensed under Business Source License 1.1, automatically converting to Apache 2.0 four years after each release. The rules are short and human-readable.

Can I use Causari at my company, on closed-source code, in production?

Yes — completely free, with no time limit. The BSL only restricts one specific use: reselling Causari itself as a hosted "causality-as-a-service". Everything else, including all internal commercial use, is permitted from day one.

Can I fork it, modify it, contribute back?

Yes. Fork it, study it, ship internal forks, send PRs. The CLA keeps Croviatrust able to dual-license in the future, but every line of code you read here will become Apache 2.0 four years from its release date — written into the license itself.

What about my prompts, model identifiers, agent reasoning?

Causari is local-first by design. The ledger lives in .causari/ in your repo. No telemetry. No accounts. No phoning home. If your reasoning leaks, it's because you committed .causari/ to a public repo — and you can prevent that by adding it to .gitignore.

Why BSL 1.1 instead of MIT or Apache?

Because we'd rather be honest. We want to keep building Causari as the category-defining tool, and the BSL is the cleanest legal way to do that without spending the next two years on a permissive license while a hyperscaler ships a managed clone. The four-year auto-conversion makes that promise enforceable: every version eventually becomes Apache 2.0, no matter what we do.

Ready to make your AI agents accountable?

One binary. Zero cloud. The first ten minutes will change how you ship code with agents.

cargo install --git https://github.com/croviatrust/causari

★ Star on GitHub Join the discussion