The guarantees below are correct and carried forward — a verification gate between recording and activating, a guaranteed floor, fertility so lineages cannot degrade, the code/data boundary, substitute-never-subtract, and zero-adaptation identity. What is retired is the parallel mechanism, not the ideas.
This project built its own object model on Git primitives, which forced one choice it should not have had to make: it derives a locus id from name + content — a name-hash — to buy "same agent, same id on every machine, with no coordination." rapp/1 forbids name-hash identity (§6.2) because collision becomes definitional. But rapp/1 also makes the trade unnecessary: a frame carries two hashes, so equivalence rides the particle (
payload_hash, reproducible from identical baseline bytes) and identity rides the wave (frame_hash, which covers the minted rappid and cannot collide). Both properties, no collision.The successor is a profile, not a protocol — no new envelope, no new verifier — and lives with the other specs: rapp-molt/0 (reference implementation:
tools/molt.py, 24/24 conformance).Archived read-only. Nothing depended on it — no installs, no forks, zero refs in any repo.
Version control for autonomous agents. Git for agents — not a reimplementation of Git, a set of conventions on top of it, so agent lineage inherits everything Git already guarantees.
Agents have begun to modify themselves: rewriting their own tools, accepting generated code, adapting per device and per user — increasingly without a human reading the diff. Every platform approaching that capability hits the same four problems, in the same order:
| Problem | What it looks like in production |
|---|---|
| Divergence | Every deployed instance is different. Nothing reproduces. |
| No floor | A bad self-modification has nothing to fall back to. |
| No provenance | Nobody can say what a running agent descended from. |
| No interchange | An adaptation learned on one instance can't move to another. |
These are version control problems. Git solved them in 2005.
Agent lineage is an ordinary Git repository:
| Concept | Git object |
|---|---|
| Generation ("ring") | a commit |
| Agent lineage ("locus") | a ref — refs/molt/loci/<locus> |
| What's running right now | a ref — refs/molt/live/<locus> |
| Factory baseline (ring 0) | the root commit — refs/molt/base/<locus> |
| Portable frame | a bundle |
| Verification verdict | a commit trailer (inside the commit hash) |
| Tamper-evidence | Git's Merkle DAG |
| Replication | fetch / push |
| Authorship authenticity | Git commit signing |
Everything Git already does well, git-molt does not do at all. It adds only
the three things Git has no opinion about:
- A verification gate between commit and checkout. Git assumes a human reviews before merge. Self-modifying agents can't assume that, so activation is gated on a mechanical check — including fertility, so lineages don't degrade across generations.
- A guaranteed floor with shared identity. Git has no notion of "the version every instance can always return to." Here the baseline is both the recovery target and the population's common identity.
- A composition contract. Version control ends at the working tree. This specifies how a resolved generation becomes what a live, lineage-unaware runtime actually loads — fail-safe, atomic, and additive.
Spec: gitprotocol-molt(5), written in Git's own
manual-page register with RFC 2119 conformance profiles.
cp bin/git-molt /usr/local/bin/ # anywhere on PATH
git molt version # git discovers git-* as a subcommandNo dependencies beyond Git itself. SHA-256 repositories are used where available.
git molt init
# Record the factory agent. The locus id is DERIVED from name + content, so the
# same agent gets the same id on every machine in the world.
LOCUS=$(git molt baseline memory ./memory_agent.py)
# The agent adapts. Recording is always allowed; activating is not.
RING=$(git molt record $LOCUS ./memory_agent.v2.py)
git molt activate $LOCUS $RING # refused: unverified
# Gate it. Your verifier decides — the candidate never emits its own verdict.
VERIFIED=$(GIT_MOLT_VERIFIER=./my-gate.sh git molt verify $LOCUS $RING)
git molt activate $LOCUS $VERIFIED # now it's live
# Materialize what the runtime loads. Fail-safe: anything unverified, missing,
# or pinned resolves to the baseline instead. Composition cannot fail.
git molt compose ./agents
# Time travel. Non-destructive — history is append-only.
git molt revert # every locus back to factory
git molt restore # forward again
# Freeze one agent for life while its siblings keep adapting.
git molt policy $LOCUS pinned
# Move an adaptation to another instance.
git molt frame export $LOCUS memory.frame
git molt frame import memory.frame # imported ≠ trusted; verify to activateBecause it really is Git:
export GIT_DIR=~/.molt/lineage.git
git log refs/molt/loci/$LOCUS # the agent's generation history
git diff $BASE $RING # what the agent changed about itself
git bisect start # find the generation that broke it
git verify-commit $RING # check who signed the verdict- Substitute, never subtract. An instance running
git-moltis never less capable than the same instance without it. Every failure degrades to the runtime's native behavior. - Zero-adaptation identity. With no molts, the composed directory is byte-identical to what you'd have without this tool. Adoption is a no-op until something actually changes.
- Fail-safe composition. Missing, corrupt, unverified, or pinned all resolve to the baseline.
- Code, not data. Reverting restores factory behavior; it never touches agent memory or user data. That's what makes reversal safe to hand to end users.
- The verdict is the verifier's. A candidate cannot forge its own pass, and the verdict lives inside the commit hash — editing it orphans every descendant.
bash t/t0001-molt.sh # 33 assertions against real repositoriesCovers determinism across unrelated instances, gate refusal, tamper-evident
verdicts, pinning, non-destructive reversal, fail-safe composition, bundle
interchange, and native git log / diff / fsck compatibility.
A profile records how a concrete host conforms. The first is
rapp-lineage — the RAPP Brainstem Frontier,
which is where this design originated and was first proven.
Implementing this on another agent platform? Register a profile by pull request. Critiques of the standard are as welcome as implementations.
Draft standard, working reference implementation. MIT licensed.