# Neighbors — where `ev` sits

Decisions deserve infrastructure, and a growing set of tools is built on that premise. This page places `ev` among them honestly: what each neighbour is for, how it works, and where `ev` takes a different path.

`ev` combines three properties:

1. an **immutable, content-addressed chain** of decisions,
2. the **grounds** a decision rests on as first-class structured data, and
3. a **falsifiable check** bound to a ground that, when it goes red, **actively resurfaces** the decision.

Properties (1) and (2) are shared with several neighbours below. Property (3) — *re-evaluating a recorded decision against a changing world and bringing it back when its premise breaks* — is the one `ev` leads with. The *idea* is not unheard of: safety-assurance-case research sketches it (the GSN row below), and decision frameworks like `haft` carry a neighbouring form. What `ev` has not found is (3) shipped as a **git-native, decision-scoped** tool — and that *implemented* instantiation, not the idea, is `ev`'s claim. That is where the differences below concentrate.

## The neighbours

| Neighbour | What it is for | How it works | `ev`'s different path |
|---|---|---|---|
| **ADR tools** — log4brains, npryce/adr-tools, MADR | Write and publish architecture decisions | Static markdown; supersession by a "superseded" status, by convention | The record is content-addressed and carries a runnable check — a broken premise brings the decision back, rather than relying on someone re-reading a file |
| **adr-kit** — [rvdbreemen/adr-kit](https://github.com/rvdbreemen/adr-kit) (its *Guardian*) | Keep ADRs from going stale for AI coding agents | A scheduled staleness sweep (session-start + a weekly CI cron that maintains one "ADR guardian audit" issue); detection is heuristic — regex *Enforcement* rules against the diff, plus age / supersession / policy-drift ranking | `ev` runs an **executed** falsifiable check that goes red on a real failure, tied to the decision's premise — not a scheduled heuristic. (adr-kit's proactive timer + auto-issue is machinery `ev` deliberately lacks — `ev` is pull-only.) |
| **Lore Protocol** ([arXiv:2603.15566](https://arxiv.org/abs/2603.15566)) | Structured knowledge for AI coding agents, in git commit trailers | Grounds-style trailers (constraints, rejected alternatives); staleness via five passive heuristics (age, code drift, confidence, expiry hint, orphaned deps), surfaced on demand with `lore stale` | Binds a *falsifiable* check that is re-run and goes red on a real failure — an executed verdict, not a heuristic staleness flag |
| **haft** — [m0n0x41d/haft](https://github.com/m0n0x41d/haft) | An engineering-decisions engine "that knows when decisions are stale" | A trust **score** (`R_eff`) that decays as evidence ages, plus `valid_until` dates; a measure step reopens a decision when a prediction fails or the score crosses a threshold | The reopen-on-failed-measurement instinct is shared, but `ev` deliberately has **no score or decay** (facts-not-verdicts): its trigger is a **binary** falsifiable check going red (gating one git hook), not a numeric trust threshold |
| **AgDR** — [me2resh/agent-decision-record](https://github.com/me2resh/agent-decision-record) | Record what an agent decided | A record format for agent decisions | `ev` watches whether the decision is *still true*, and inverts the authorship line — a human ratifies and stays on the hook |
| **Decision ledgers** — agentic-decision-ledger, ElixirData | Govern decisions at decision time | Pre-execution admissibility gates; ElixirData adds a live decision stream and a manual "replay" of a past decision | `ev` does not gate at write time; it re-checks a *recorded* decision later, automatically, when the world it rested on moves |
| **Agent memory** — Mem0, Zep/Graphiti, Letta/MemGPT | Remember facts and context across sessions | Passive recall; contradictions surfaced reactively | `ev` is active: it binds a check and resurfaces — judgment and governance, not recall |
| **Signed-provenance / agent identity** — content-addressed + signed memory protocols (BLAKE3 + Ed25519), agent-identity schemes | Cryptographic provenance and capability boundaries for agent memory | Signed chains; identity and authorization | `ev` is honest-by-construction — provenance is *declared, not cryptographic*; integrity is *tamper-evident* (`ev verify` detects edits), not write-enforced. None of these watch a decision's premise |
| **Architecture-fitness / policy-as-code** — ArchUnit, OPA, fitness functions | Enforce architectural rules in CI | Block the build on a violation | `ev`'s default posture is to *resurface*, not block; blocking is opt-in (`--exit-on-red`) and scoped to the git hook — and it ties the check back to the *past decision and its grounds*, not just "a rule was violated" |
| **Safety-assurance cases** — GSN runtime-assurance ([arXiv:2511.14805](https://arxiv.org/abs/2511.14805)) | Argue a safety case stays valid at runtime | A `<<RuntimeAssumptionMonitor>>` on a goal node that, on a violation, marks the node `<<Reopened>>` — the same monitor-on-a-recorded-assumption → reopen shape as `ev`'s (3) | The *concept* matches, but it operates on safety-case **goal nodes** in a modelling notation (the shipped artifact is a design-time plugin), not human **decisions** in a git-native chain. `ev` is that idea *implemented*, *decision-scoped*, and *git-native* |
| **Governance frameworks** — NIST AI RMF (MEASURE 2.4 / 3.1), EU AI Act Art. 12 | Standards and regulation for AI monitoring and logging | Frameworks and mandates | `ev` is a single-binary substrate that can help satisfy a continuous-monitoring outcome (e.g. NIST MEASURE 2.4/3.1) — advisory alignment, not a compliance product |

## Honest edges

- **Shared ground.** An immutable chain and first-class grounds are not unique to `ev` — Lore, for one, has both. Even the *active resurface* idea is not unheard of — it appears as a concept in safety-assurance research (the GSN row) and a neighbouring form in `haft`. What `ev` has not found is that idea shipped as a *git-native, decision-scoped* tool with a binary executed check.
- **`ev`'s own gaps.** Provenance is **declared, not cryptographic** — signing is a deliberate non-goal, not a shipped feature. Immutability is **tamper-evident** (`ev verify` flags any edit), **not** write-enforced; `ev` is advisory, never a gate beyond a git hook. It fires on git-recorded change, never on external-state drift that leaves no commit.
- **No universal claim.** "Not found elsewhere" means exactly that — a survey, not a proof of a vacancy. If a tool already watches a decision's premise and resurfaces it, that is a neighbour we have not yet met, and we would want to know.
