Causari MCP server
Commit Nov 9, 2026Records agent declarations including prompts, models, and files to track the causes of AI-generated code via an MCP server.
Also known as croviatrust/causari
- Stars
- 9
- Tools
- —
- Downloads, 30 days
- —
- Latest version
- 0.5.0
- Last commit
- Nov 9, 2026
- License
- Apache-2.0
What is Causari MCP?
Causari records agent declarations including prompts, models, and files to track the causes of AI-generated code via an MCP server.
Summary generated from the project's README
About Causari MCP server
Causari provides a way to track the origins of AI-generated code by recording agent declarations and auditing git history. It functions as an MCP server that exposes a local ledger containing specific details about agent runtimes, such as the prompts used, the models employed, and the files accessed. This allows developers to move beyond simply knowing which commits were AI-assisted to understanding the specific causes behind the code.
Users interact with the system through the re binary, using commands like re audit to calculate survival rates of code lines and re mcp to expose the local ledger via the Model Context Protocol. The tool works locally on any git repository without requiring cloud accounts or complex setup. It uses git metadata, such as bot authors or Co-Authored-By trailers, to identify AI-tagged commits and compares their persistence against an untagged baseline. A Seal can be used to authenticate that specific bytes were signed for a given commit and method.
What you can do with it
- 1Audit code survival ratesCalculate how many lines from AI-tagged commits are still present in the current repository head.
- 2Expose agent runtime detailsProvide an AI client with access to a local ledger of prompts, models, and files used during agent execution.
- 3Compare different audit snapshotsIdentify changes in metadata or methods between two different audit JSON files.
Written from the project's README. Every use case is checked against a quote from it.
Automated checks
Ran Nov 13, 2026Full report →Not verified yet. A server needs a score of 80, no serious finding, and enough data for us to check. How checks work · What to fix for more points
- Source repository linked and reachablecroviatrust/causari is public and reachablegithub.com/croviatrust/causari ↗Pass
- Package names this repository as its sourceNot checked
- Build provenance (Sigstore attestation)Not checked
- Open source license (OSI)Apache-2.0spdx.org/licenses/Apache-2.0.html ↗Pass
- Commit or release in the last yearLast commit or release 2026-11-09github.com/croviatrust/causari ↗Pass
- OpenSSF ScorecardNot checked
- Package name not close to a popular packageNot checked
- No critical advisory in the package or its dependenciesNot checked
- No hidden instructions to the model0 tool descriptions and the README read; no override phrases, credential paths or hidden charactersPass
- Destructive tools are labelledNot checked
- Remote endpoint answers the MCP handshakeNot checked
README
View on GitHubre audit counts lines introduced by commits whose git metadata matched an AI-detection rule, and how many of those lines git blame still attributes to those commits at HEAD. That count is survival: a count, not a grade. AI-tagged means the metadata matched. It does not prove a model wrote the line. UNKNOWN (no such metadata) is not human.
Causari also keeps a local ledger of what an agent runtime declared (prompt, model, files) and exposes it over MCP (re mcp). A Seal authenticates that a key signed these bytes for this commit and method. It does not authenticate that the numbers, or the attribution, are true.
Method and limits: causari.dev/method. The same limits, for an agent, in one file: causari.dev/llms.txt (full specification and schemas: causari.dev/llms-full.txt; agent discovery card: causari.dev/.well-known/agent.json).
curl -fsSL https://causari.dev/install.sh | sh
re audit
re audit vercel/next.js # any public repo, cloned to a temp dir and removed after
$ re audit
∵ causari · AI code survival
───────────────────────────────────────────────────
216 commits analyzed (git metadata only, no setup required)
AI-tagged (metadata matched): 14 commits, 6267 introduced, 5185 survived
survival 82.7% line-weighted · 82.7% capped · median 92.8%
Of the lines introduced by metadata-matched commits, this percentage is the share `git blame -w -M -C` still attributes to those commits. It is not the share of the repository and it is not a quality score. Metadata matched does not prove who wrote each line. UNKNOWN and untagged are commits with no such signal; they are not a finding that a human wrote them.
Age-matched gap: +2.9 percentage points (AI-tagged 85.6% minus untagged 82.7% in the matched age windows). Positive means the metadata-matched lines have the higher line-weighted survival in those windows, over 1 matched age window holding 75% of the AI-tagged lines. Lines outside those windows are not in this gap.
Probable AI-assisted: none detected
By agent (metadata matched only)
agent commits introduced survived line-wt capped median
cursor 14 6267 5185 82.7% 82.7% 92.8%
Baseline: untagged lines of the same repository
untagged: 202 commits, 95759 introduced, 76085 survived · 79.5% line-weighted · 92.1% median
line age AI-tagged untagged
0-30 d 85.6% (13 commits) 82.7% (142 commits)
30-90 d — 75.8% (23 commits) (below floor on one side)
90-180 d 73.9% (1 commit) 62.6% (37 commits) (below floor on one side)
Age-matched gap: +2.9 percentage points (AI-tagged 85.6% minus untagged 82.7% in the matched age windows). Positive means the metadata-matched lines have the higher line-weighted survival in those windows, over 1 matched age window holding 75% of the AI-tagged lines. Lines outside those windows are not in this gap.
Confidence notes
· JSON field `verified` = metadata matched (trailers, bot author, …), not authorship proved
· PROBABLE = weak heuristic; may include human-assisted commits
· UNKNOWN commits are excluded from headline numbers; they form
the untagged baseline (human, inline-completed and untagged-agent code alike)
· Only lines from AI-tagged commits are measured; inline completions
(Copilot, Cursor Tab, …) leave no git trace and are invisible here
· A measurement, not a grade: method v4 at https://causari.dev/method
Reading and export
· The age-matched gap above is the comparison. An agent row marked below floor is not comparable.
Meeting the floor is not a reliability guarantee.
· Export: `re audit <target> --json`, `--summary`, `--seal`, `--badge`, `--card`
`re report` reads the local ledger. It does not export this audit.
The percentage is how many lines git blame still attributes to commits this method tagged. It is not code quality, developer productivity, total AI usage, proof a model wrote the line, security, correctness, or a causal effect of AI. An agent row under 5 commits is marked below floor; 5 commits is the comparability floor, not a reliability guarantee.
A git-ai note counts only when it names a non-empty tool (method v4). A schema-only note, a human-only note, and an empty tool do not. Method v3 counted any git-ai note. Survival Reports #1 and #2 stay method v2. Reports #3 and #4, and any audit from the 0.3.0 release, stay method v3. Report #4 is 10.5281/zenodo.23196011. Reports #5 and #6 stay method v4, measured with causari 0.4.1 (commit d4c4949, 2026-10-08). The published binary 0.5.0 (2026-10-21) is method v6, the method this source computes: surviving reads the same paths as introduced, so a binary blob (a PDF, an image) adds lines to neither count and a symlink adds one line to both; coverage.binary_files says how many blobs were left out. No binary shipped method v5. Published reports are not recomputed.
Fifteen minutes
curl -fsSL https://causari.dev/install.sh | sh
cd /path/to/a/git/repo
re audit
Read three lines of the output. AI-tagged (metadata matched) is the cohort whose commit metadata matched a rule. Baseline is every other commit: untagged, not "human". The survival percentage is the line-weighted persistence of the tagged cohort. It does not prove who typed the code. The rules and the limits are at causari.dev/method.
The ledger is a second path, local and gitignored, used only if you record:
git history → re audit → survival counts
hooks or proxy → .causari/ → re why / trace / lens
A seal signs the audit bytes. It does not connect the two paths.
Everyone argues about how much code AI writes. Nobody can check the numbers.
re audit reads plain git history — Co-Authored-By trailers, bot authors,
agent markers — finds the commits whose metadata matched, and asks git blame
how many of their lines are still at HEAD. Metadata matched is not proof a
model wrote the line. No model, no estimate, no survey. --json stores the counts, repository.head, repository.root_commits, the method, the blame and numstat flags (coverage.blame_flags, coverage.numstat_flags), coverage.ignore_revs_sha256 and coverage.notes_oid (the target OID of refs/notes/ai when present). It does not store the note payloads of refs/notes/ai: that ref is not part of the commit object, and changing it changes coverage.notes_oid and can change the counts while the commit SHA stays the same. A
repository that has moved has a different commit.
--jsonthe exact bytes behind any published row (the published rows themselves: causari.dev/reports/survival, also as a dataset at CroviaResearch/causari-survival)--summaryMarkdown for CI;--badge/--cardone-colour SVGs--diff <before> <after>compare two audit JSONs or.seal.jsonbundles along one axis (repository_diff,method_diff,indeterminate_method_diff,metadata_diff, oridentical_inputs), refusing multi-axis diffs and unrelated repositories--saveappend a snapshot to track your own trend
Compared with what: since method v3 every audit puts the repository's own untagged lines next to the AI-tagged ones, by line age, and states the age-matched gap: AI-tagged survival minus untagged survival inside the matched age windows of the same repository, not a comparison of identical timestamps. It also names the oldest line still at HEAD and how many commits predate it: a repository that was cleared or rewritten shows there, and its ratio is read accordingly.
What it cannot see: code from inline completions (Copilot, Cursor Tab,
Windsurf, …) leaves no git trace, so it is in the untagged baseline.
Untagged is not a finding that a human wrote it. Commits without a trailer
are UNKNOWN. An agent that needs the same limits in one file should read
causari.dev/llms.txt. A formatter pass
or a moved function counts as a death under method v1. One bulk commit can
dominate a line-weighted ratio; ratios under 5 AI-tagged commits are
flagged. All of this is written out at
causari.dev/method, with how to contest a number.
The questions people ask, answered with the command and the limit: causari.dev/faq; how this differs from git blame, vendor dashboards and churn reports: causari.dev/compare.
The weekly Survival Report runs
re audit on up to 100 open-source repositories: a hand-picked list plus the
most-starred public repositories (at least 100 stars) where GitHub commit search
finds at least five commits carrying the same AI authorship metadata, selected
every week, the day before the report, by
scripts/survival_discover.py under a rule
stated on the method page; rows stay
alphabetical, and one line in .github/survival-optout.txt removes a repository.
In CI: a count on every pull request
# .github/workflows/causari.yml
on: pull_request
permissions: { contents: read, pull-requests: write }
jobs:
audit:
runs-on: ubuntu-latest
steps:
- uses: actions/checkout@v4
with: { fetch-depth: 0 } # the audit reads every commit; shallow clones are wrong
- uses: croviatrust/causari@v1
The Action
downloads the prebuilt Linux binary (a few seconds), runs re audit --summary,
writes it to the job summary and posts one sticky comment per PR. No cloud,
no account. A live example.
The ledger: from "which commit" to "which prompt"
The audit works on any history. If you also want to know why a line exists
— the prompt, the model, the files the agent read — Causari records agent
actions as they happen into a local, append-only ledger (.causari/,
gitignored), with a snapshot of the tree before and after each one.
re init # create .causari/ (added to .gitignore)
re hook claude-code # record every Claude Code prompt and edit, exactly
re hook cursor # same for Cursor, via its hooks.json (prompt, edit, model)
re proxy # local LLM proxy: prompts, models, tokens, cost
re watch # attribute file changes to captured completions
re why src/auth.ts:42 # which recorded event introduced this line
re trace src/auth.ts:42 # upstream: events that fed into it through reads/writes
re impact <event-id> # downstream: what later events depended on it
re lens src/auth.ts # the file annotated line by line with its event
re find "the JWT refactor" # search prompts, messages, reasoning
re bisect --test "npm test" # first recorded event that breaks a test
re revert <id> # restore the pre-state, with a preview of what else you undo
re fork / re sessions / re switch / re log --all / re diff a..b
What each agent actually gives you today
Claims about "any agent" are cheap. This table is derived from the code and is kept current; if a cell is wrong, open an issue.
| Agent | Prompt + file, exact | Model, tokens, cost | How |
|---|---|---|---|
| Claude Code | yes, via lifecycle hooks | not yet (edits travel as tool_use, which the proxy does not join to files yet) |
re hook claude-code |
| Aider | heuristic join, measured | yes | OPENAI_API_BASE / ANTHROPIC_API_BASE → re proxy + re watch |
| Codex CLI, OpenAI Agents SDK | not yet (Responses API output not parsed) | yes | OPENAI_BASE_URL → re proxy |
| Cursor | yes, via native hooks | model yes (the hook names it); tokens and cost no (Cursor's model calls do not pass through re proxy) |
re hook cursor |
| Windsurf, Copilot | only what the agent self-reports via MCP | no | re mcp |
| Cline / Roo, custom scripts, curl | heuristic join when the completion carries the code as text | yes | base URL → re proxy + re watch |
Two evidence classes, and every output says which one it is:
- Declared (hooks, MCP,
re record): the agent stated what it did. Exact prompt and path. If a human edits a file between two hook events, the hook snapshot absorbs that edit into the next agent event — a known limit being fixed in Phase 1. - Correlated (proxy + watch): the lines you inserted are searched inside
completions captured moments before. A score, not a fact. The adversarial
harness in
examples/real-session/gives measured numbers: 100 % on a clean write, 50 % after a formatter pass, wrong per-line attribution when two prompts touch one file in the same window.
Everything stays on your machine. re proxy and the hooks store prompts,
completions and commands in clear under .causari/ (gitignored); credentials
in recognisable formats — sk-… keys, GitHub/GitLab/Slack/npm/PyPI/Hugging
Face tokens, AWS and Google keys, bearer values, JWTs, PEM private keys — are
replaced by [redacted:<kind>] before writing, and the record says how many.
Anything else you paste is kept as typed. Snapshots store every non-ignored
file (.env*, node_modules, target, dist, build, .git and a few
others are excluded by default). Treat .causari/ as sensitive. What is
stored, what is not, and what the tool does and does not defend against:
SECURITY.md and docs/threat-model.md.
Receipts you can verify without us
Crovia Seals. re proxy --seal issues a
crovia.seal.v1 receipt for every
completion: Ed25519-signed, hash-chained, committing to SHA-256 hashes of the
exact request and response bytes (content never leaves the machine). Each
recorded exchange carries its seal_id and the same hashes, so a receipt can
be matched to the completion it covers. The implementation passes the
reference conformance vectors; seals verify under the Python reference
implementation and vice versa.
re proxy --seal # issue a receipt per completion
re seal verify # every signature, whole chain, offline
re seal issuer # your issuer id and public key (read-only)
PNX — Proof of Non-Exfiltration. re proxy --pnx makes the proxy an
egress witness for the TACET profile
crovia.pnx.v1: every request
body is fingerprinted (salted winnowing, k-gram 32, window 16) and committed
to a sparse Merkle map before it is forwarded; Ctrl-C signs a run sheet
carrying the root. re pnx prove then shows, for a set of protected assets,
that none shared a substring of 47 bytes or more with that traffic — or
records which did. Sheet and proof contain no traffic bytes and no asset
bytes, and verify offline with re pnx verify or with the Python reference
tacet-pnx, in both directions, same verdicts and exit codes. The sheet also
states where the run connected — every upstream the proxy forwarded to,
with its outcome under an egress policy bound by hash (the reach record,
PNX §4a); a destination outside the policy is refused before the body
leaves. What a proof does and does not say: docs/pnx.md.
re proxy --pnx --pnx-policy egress-policy.json # witness a session; upstreams outside the policy are refused; Ctrl-C signs the sheet
re pnx prove --asset api_key=.env --assets-dir src/secret/
re pnx verify .causari/pnx/<run>/proof.json --asset api_key=.env --assets-dir src/secret/ --policy egress-policy.json
Audit seals. re audit --seal writes the audit result as the same kind of
receipt: a crovia.seal.v1 over the exact bytes of re audit --json, bound to
the audited commit and the method version, hash-chained with the proxy's
completion seals under one issuer key per repository. re seal verify FILE
checks it offline; so does the static page
causari.dev/verify, which makes no network
request. A valid seal proves that this key signed these numbers for this
commit and that they were not altered since. It does not prove the numbers
are true: rerun re audit on the commit and compare. (re proof is retired
in favour of this; it exits 2 and names the replacement.)
re audit --seal --output audit.seal.json
re seal verify audit.seal.json
re audit --diff before.seal.json after.seal.json --summary
Experimental
These commands exist, work in the demos, and are not yet held to the standard above. They are out of the proof and out of the front page until they are.
re skill distill / verify / export / import / pull / trust: signed units of past work. Ed25519 detects a later edit; the signature does not certify the content.verifiedis a declared signal frozen at distill (a caller-supplied exit code 0, or declared write paths still at the tip), not an observed success. A 2× rank weight is that declared signal, not measured reliability.provenis not awarded. A legacy recall count is not an execution.re brief: a Markdown briefing of past work for a model's context.re guard: substring rules over recent changes; gates a build only when asked (--fail-on alert|warning);--jsonfor machines.re churn,re report: survival measured over the ledger instead of git, with cost extrapolated from a static price table;re churn --json, and--fail-below <percent>when a team wants a floor of its own choosing.re mcp: stdio MCP server withcausari_record,causari_recall,causari_why;re mcp --installprints the client config.
Install
# Linux / macOS
curl -fsSL https://causari.dev/install.sh | sh
# Windows (PowerShell)
irm https://causari.dev/install.ps1 | iex
# Homebrew (macOS, Linux)
brew install croviatrust/tap/causari
# Scoop (Windows)
scoop bucket add causari https://github.com/croviatrust/scoop-bucket && scoop install causari
# crates.io (Rust 1.85+)
cargo install causari --locked
# no install: launchers that fetch the verified binary on first run
npx causari audit
pipx run causari audit
# from source
cargo install --git https://github.com/croviatrust/causari --locked
One program under two names: causari is the binary, re is the short alias
every example uses. Both are in every archive and both are installed. One
static binary, about 5 MB, for Linux (x86_64, aarch64), macOS (x86_64, Apple
silicon) and Windows (x86_64), installed to ~/.local/bin (or
%LOCALAPPDATA%\Programs\causari). The installer checks the archive's
SHA-256 against the SHA256SUMS.txt published with each release and refuses
to install on a mismatch. From v0.2.0, every archive and the sums file carry a
signed SLSA build-provenance attestation from the release workflow:
gh attestation verify causari-v0.5.0-x86_64-unknown-linux-gnu.tar.gz --repo croviatrust/causari
By hand:
VERSION=$(curl -fsSL https://api.github.com/repos/croviatrust/causari/releases/latest | sed -n 's/.*"tag_name": *"\([^"]*\)".*/\1/p')
TARGET=x86_64-unknown-linux-gnu
base="https://github.com/croviatrust/causari/releases/download/$VERSION"
curl -fsSLO "$base/causari-$VERSION-$TARGET.tar.gz" && curl -fsSLO "$base/SHA256SUMS.txt"
sha256sum --ignore-missing -c SHA256SUMS.txt && tar -xzf "causari-$VERSION-$TARGET.tar.gz" && install -m755 causari re ~/.local/bin/
The Homebrew tap and the
Scoop bucket render their
manifests from each release's SHA256SUMS.txt and re-render every six hours.
The crate is published from the release tag through crates.io Trusted
Publishing (.github/workflows/publish-crate.yml): no long-lived token exists.
As an MCP server
re mcp speaks MCP over stdio and exposes causari_record, causari_recall
and causari_why; re mcp --install prints the configuration block for
Claude Desktop, Cursor, Windsurf and Cline. The server is listed in the
MCP Registry from
server.json:
- MCP Registry name: mcp-name: io.github.croviatrust/causari
- One-click for Cursor: Add causari to Cursor
(registers
re mcp; the binary must be onPATH)
In Cursor
re hook cursor merges seven command hooks into the project's
.cursor/hooks.json (commit it: teammates and Cursor cloud agents run it
from the repository root); --user merges ~/.cursor/hooks.json instead
for one machine, --dry-run prints the result. Hooks other people wrote in
the same file are kept. Each hook runs re hook-event cursor:<event>, so
re must be on PATH for the Cursor process (the same caveat as the Claude
Code hooks); without it, or in a project without re init, every hook
answers with a neutral JSON object and nothing is recorded. What lands in
the ledger: the prompt with its attachments and model
(beforeSubmitPrompt), a snapshot before each shell or write tool
(preToolUse), one event per written file (afterFileEdit) and per
command that changed the tree (afterShellExecution), the agent's answer
next to its prompt (afterAgentResponse), and the experience briefing as
context at sessionStart.
Causari MCP questions
What information does the Causari ledger record?
The ledger keeps a local record of what an agent runtime declared, specifically the prompt, the model used, and the files involved.
Can Causari detect code from inline completions like GitHub Copilot?
No, inline completions leave no git trace and are therefore invisible to the tool and included in the untagged baseline.