I built this because no MCP server speaks pacs.008 natively. It's backed by AWS CardDemo (COBOL credit card system) modernized to ISO 20022. Four tools: validate_message, get_statement, payment_status, initiate_payment — all with FINOS AIGF governance middleware. Part of a larger legacy modernization framework (EvolutionAI). Blog writeup with the full architecture: [Medium link]
Appreciate it. SurvivalIndex is agnostic to LLM or coding agent. One of the more interesting findings when you run the same
prompts across Claude, GPT, and Copilot is that tool
selection diverges significantly by model. Claude Code picks
Drizzle for ORM in JS at 100% on Opus, while Sonnet still
defaults to Prisma at 79%. Older models route to Redis for
caching, newer models increasingly go Custom/DIY. The
"recency gradient" shows up clearly — newer models pick
newer tools, sometimes before the ecosystem has validated
them.
This matters because a tool's survival score shouldn't be
measured against one agent. A tool that only one model
knows about has a structural awareness problem. A tool
three models independently converge on has something real.
One thing I'd love input on: we use expert human ratings as a variable (H) to capture whether agent choices align with what experienced engineers would actually ship. Curious if people think this is the right signal or whether it introduces too much subjectivity.
I built this because I kept running into the same problem at work: an AI agent (Claude Code, Cursor, etc.) would make changes to our codebase, and a week later nobody could explain why it chose to delete a file instead of editing it, or why the same prompt produced different results on Tuesday vs Thursday.
The debugging loop was brutal. No execution trace. No way to compare two runs. No way to prove that an artifact was produced by a specific agent invocation. We were flying blind.
ContextSubstrate is a CLI tool that treats agent runs the way git treats code changes — as immutable, content-addressed snapshots you can inspect later.
Three core operations:
ctx capture — Records an agent run into a Context Pack: the prompt, tool calls, model params, input files, timestamps, environment metadata. Everything gets hashed. You get back ctx://sha256:abc123 — share that hash, and anyone can reproduce the run.
ctx diff <hash-a> <hash-b> — Compares two runs and shows where decisions diverged. Did the model pick a different tool? Did a parameter drift? Did the prompt change? It outputs a structured diff of decision points, not just text diffs.
ctx verify <artifact> — Traces any file back to the Context Pack that produced it. "Who wrote this code, when, and with what instructions?"
What it's not:
Not an agent framework (use whatever agent you want)
Not an observability dashboard (no cloud, no SaaS)
Not a prompt IDE
It's infrastructure. Local-first, Git-compatible layout, JSON + content-addressed blobs. Written in Go.
The closest analogy is: git gives you blame, log, and diff for human-written code. ContextSubstrate gives you the same primitives for agent-written code.
Early stage — the CLI works, Context Packs are solid, and diff/verify are functional. Looking for feedback from anyone who's dealt with "my agent did something last week and I can't figure out what" problems.
GitHub: https://github.com/scalefirstai/ContextSubstrate