Morph is a version control system that records every agent session as an immutable Run with a full Trace, attaches evaluation scores to commits, and gates merges on behavioral dominance — not just a clean text diff. It's an open research prototype. We're building it in the open and we want your help.
The Problem
When an agent writes your code in Cursor, Claude Code, or OpenCode, Git snapshots the file tree and tracks line-level diffs. But it has no idea how those files arrived — and it can't tell you whether the result still works.
Which prompt produced this refactor? Which conversation led to this bug fix? Git has nowhere to store any of that.
The agent may try three approaches before settling on one. Tool calls, file reads, shell commands, token usage — none of it survives the commit.
You can't read a diff and know whether the tests still pass, the benchmarks improved, or the agent regressed an edge case. You have to run it.
Which agent, which model, which prompt, under which environment — all of it matters for reviewing and reproducing AI-authored changes.
Two agent branches can merge cleanly at the text level while the resulting code fails tests that both parents passed.
Git assumes identity is byte equality and reproducibility is identical output. Neither holds when an LLM is in the loop.
Our Thesis
Same content-addressed Merkle DAG as Git. Same hash-of-contents identity.
Three additions that we believe make version control work for agent-authored code.
Morph runs alongside Git (separate .morph/ and .git/) —
drop Git later if you want to. The ideas below are where we're heading; the
implementation is partial and actively being built.
Every agent session is recorded as an immutable Run with a full Trace: every prompt, response, tool call, file read, file edit, shell command, and token count. IDE hooks parse the agent's complete transcript into structured events, so recording is always-on and doesn't depend on the agent calling a tool.
A Morph commit stores a file tree hash and an optional behavioral
contract: which pipeline was run, which evaluation suite, what scores were
observed, and in which environment. Plain morph commit -m "…"
still works exactly like Git when you don't need evaluation gating.
Instead of three-way text merge alone, morph merge requires the
candidate to dominate both parents' certified metrics: at least as good on
every declared metric. If the merged code regresses on anything,
the merge fails. morph merge-plan previews the bar to beat
before you merge.
IDE Integrations
Morph ships with an MCP server (morph-mcp) and setup commands that
install the right config, hooks, and rules for your IDE. Hooks parse the full
agent transcript into structured Trace events, so every prompt, tool call, and
file edit is recorded — you don't depend on the agent remembering to record.
MCP server, hooks for always-on recording, and rules for behavioral commits. Writes into .cursor/.
MCP server and hooks for Anthropic's coding agent. Records tool calls, file edits, and shell invocations.
MCP config, AGENTS.md, and a recording plugin — one command, fully-traced sessions.
Try the Alpha
Build the two binaries (morph and morph-mcp), initialize
a Morph repo in your project, and wire up your IDE. Morph runs side-by-side with
Git — commits in one are independent of commits in the other.
Heads-up: this is alpha software.
Some commands are half-built, the on-disk format may change (use
morph upgrade to migrate), and we'd love to hear what breaks —
file an issue.
How It Works
Morph mirrors Git where possible: if you know Git, you know Morph. The CLI adds commands for recording agent sessions, certifying commits against policy, and inspecting traces.
Design Principles
Morph is built on a small set of axioms. Violate any of them and something breaks.
Content-addressed, immutable objects. Every object is identified by a hash of its contents. History cannot be tampered with.
Evidence does not rewrite history. Runs, traces, and evaluation results never mutate prior commits. New evidence produces new objects.
Pipeline steps compose cleanly. Sequential chaining and parallel execution are well-defined — like Promise.then() and Promise.all().
Evaluation suites are explicit contracts. "Better" is never implicit. Metrics, directions, fixture sources, and aggregation methods are all versioned and hashed.
Scores are partially ordered. One scorecard dominates another only if it wins on every metric. If A is more accurate but slower, they're incomparable.
Merge records scores from both parents. Every merge commit records what both parents achieved and what the merged code achieved.
Environment is part of the record. Model version, sampling settings, toolchain — without this, scores from different environments aren't comparable.
Reproducibility means re-running the checks. You can't get identical outputs from an LLM. Reproducibility means re-running the evaluation and getting consistent aggregate scores.
Where We Are
We think the problem is real and the thesis is right. The implementation is genuinely alpha: some of it works well, some of it is held together with duct tape, and a lot of it needs your eyes, your bug reports, and your PRs. Here's where things stand today.
morph setup commandinit, add, commit, log, diff, branch, checkout, merge, tag, stash, revertmerge-plan previewcertify, and gate for pass/fail enforcementmorph serve: local browser UI + JSON API for inspecting commits, runs, tracesmorph upgrade migrations before v1.0We're a small research project and every issue, PR, and conversation moves this forward. Star the repo to follow along, or grab an open issue and start hacking.
The formal model — pipelines as monadic computations, certificate vectors, the merge monotonicity theorem — plus a concrete v0 system design with object schemas and CLI reference.
Morph: Version Control for AI-Assisted Development
Raffi Krikorian · Mozilla