Turning shared project context into deterministic delivery with near-zero drift — for human–AI collaboration, across any AI vendor.
Context is re-explained every session; decisions are silently forgotten or contradicted; each AI tool hoards its own steering files — no shared, durable project memory.
Agents are creative, but keeping what's built faithful to what was intended is unmanaged. Reversed decisions and "confidently wrong" facts pile up.
The bottleneck isn't the model — it's the architecture around it.
memory/An event-sourced ledger projected into live state — deterministic decay, supersession, provenance. Faithful to what happened.
A cognitive loop with an enforceable intent trace and human gates. Faithful to what was intended.
No-code, markdown-only. The files are the product; the agent is the runtime.
continuity.md is recomputable from them by replay.A reversed/false fact is marked superseded — change, not just disuse.
Never-decay facts are periodically re-confirmed by a human. Never-decay ≠ never-checked.
A new fact is scanned against existing ones at write time — never pick a winner.
Each fact traces to its source session — one hop; anti-poisoning by design.
Retrieval stays lexical + indexed by design — auditable and replayable, not a black-box vector store.
memory/.The loop mostly already exists in the memory layer — we integrate by mapping, not rebuilding.
| Primitive | Realized by |
|---|---|
| Current State | continuity.md |
| Vision new | memory/vision.md — the north star |
| Blueprint new | typed (blueprint) Open Threads = the gaps |
| Design | Key Decisions + Architectural Invariants |
| Implementation | code / commits, traced in sessions |
| Feedback | the review ritual + decay + supersession |
ids. A missing or broken link is drift — and it's grep-detectable.Memory and steering were already shared across vendors. Skills — reusable capabilities — are the third leg: one neutral, committed source of truth, runnable by any agent.
Committed agent-skills/<name>/SKILL.md — a name, a when-to-use description, a procedure. The single source of truth; travels with the repo.
The AGENTS.md "Skills" baseline: when a task matches, the agent reads & follows the skill. The agent is the runtime — any vendor, no engine.
Regenerated, gitignored pointers across six vendors — Claude, Gemini, Cursor, Kiro, GitHub Copilot & Google Antigravity — give native auto-trigger; never copies, so the neutral skill never drifts.
Migration promotes a vendor's skills (e.g. .claude/skills/) into the shared layer — originals preserved under legacy/, never flattened into steering.
Installed into every enabled repo, tool-managed. They sort along the principle the layer learned the hard way: mechanize the arithmetic, leave the judgment to the agent.
memory-lint — 9-check integrity verifier (Python and Node)refresh-metadata — recompute every fact's tier/usagearchive-fact — the archive move, truncation-proofsync-adapters — regenerate the 6 vendor adaptersharvest-knowledge — distil durable facts from docssecond-opinion — snapshot for a clean-memory reviewerapply-critique — bounded, human-gated apply loopWhy: capable agents silently do half a multi-step ritual. The fix is structural — a runnable helper for the arithmetic + a lint advisory for the gap — never automating the decision.
A long session over-trusts its own trajectory. The highest-value antidote is a reviewer with clean memory — a fresh session or a different vendor that didn't live the work. Shipped as two built-in skills, installed into every enabled repo.
The snapshot is distilled from continuity.md + recent sessions — never a parallel state file. Behind a security advisory you must acknowledge before any state leaves the perimeter.
apply-critique plans a few scoped fixes, runs deterministic checks (build/tests + memory-lint), then summarizes applied vs. rejected. The human gates the result.
A clean reviewer can be confidently wrong (one once over-archived live facts). So critique is advisory, gated by deterministic checks + a human — the lesson baked in.
A ritual that depends on the agent self-triggering fails the moment it lands with an untrained team. So execution got hardened, not just documented — zero manual user step.
A committed post-commit git hook auto-stubs a missing session log + re-syncs adapters; a CI floor runs memory-lint with zero per-user setup. The tool runs nothing — git & CI do.
One idempotent init.sh regenerates adapters & activates the hook on a fresh clone; .gitattributes pins shell scripts to LF so Git for Windows can't break them.
MERGE.md + safe-writeConflict resolution that never picks a winner (clash → preserve both + Contradiction); and a read-into-memory-write-once discipline that makes the old truncate-before-read bug structurally impossible.
Enable opens with an exec summary + cancel gate — informed consent before a single file is written.
"AI enable this repo" detects whatever AI footprint already exists, folds it into the shared layer, and routes that vendor's agent to the one hub — originals preserved, never deleted.
Steering folds into memory/; chat history becomes session logs; a vendor's skills are promoted into the neutral agent-skills/ layer.
We bet on AGENTS.md (steering) and the open Agent Skills standard (capabilities). Tools that adopt them — Kiro, Copilot, Antigravity, Codex — plug in with little or no glue. Each shipped as a point release.
One shared memory; thin per-vendor pointers route every agent (Claude, Gemini, Cursor…) to one hub. No lock-in.
No build/lint/test. Git-native governance: immutable ledger + mutable projection + replay.
Every decision is counting or comparing integers — reproducible across agents and runs.
Loop over process; simplicity over completeness. No ceremony.
Contradictions and the Vision are surfaced for a human, not resolved silently.
Versioned; an older repo upgrades in place via an idempotent, non-destructive ladder.
A full rewrite delivered against recorded intent — invariants, decisions, and their why pinned and traceable — deterministic, faithful, no drift.
The tool carries its own memory, Vision, and Blueprint — and the VBDI layer was designed using the VBDI loop. Using the thing to build the thing.
Driven end-to-end on a large Accenture repo by GitHub Copilot / Gemini 3.1 Pro. It even independently reinvented refresh-metadata — converging on the design that shipped.
An industry-alignment self-assessment's known gaps — supersession, invariant re-checking, contradiction, evaluation, provenance — all shipped as additive, versioned releases.
| Dimension | Common practice | agent-memory |
|---|---|---|
| Persistence | per-vendor files / vector store | one shared, git-committed markdown layer |
| Forgetting | similarity scores, TTLs | deterministic tiering by counting |
| Truth maintenance | overwrite / let stale persist | supersession + contradiction + re-verify |
| Intent → delivery | unmanaged | VBDI trace, grep-detectable drift |
| Governance | opaque | git history + markdown + human gates |
| Vendor coupling | locked to one tool | neutral; one hub |
| Capabilities | per-vendor skill files | neutral agent-skills/: 7 built-ins × 6 adapters; any agent |
| Ritual execution | relies on the agent self-triggering | git hook + CI + runnable helpers; arithmetic mechanized, judgment left to the agent; no manual step |
legacy/, never deleted.Memory is the deterministic substrate.
The loop is the lightweight control layer.
Next (tracked as Blueprint gaps): greenfield flow · more multi-user hardening (MERGE.md shipped) · an optional SDLC overlay for teams that want it.
Predictable innovation with human partnership — bold ideas, faithful delivery, the human in the loop at every altitude.