Memory

A memory has to earn its place.

Antumbra keeps what your work teaches it, and it keeps track of how much each memory deserves to be believed: how often it has helped, whether its code still exists, and who is allowed to read it.

Standing

Trust is earned by use, and lost by being wrong.

A new memory starts at 0.60. Each time it helps, reinforcement moves its confidence a quarter of the way to 1. Each time it misleads, a penalty moves it a quarter of the way to 0. Nothing ages out on a timer: a fact about your stack from a year ago is as good as the day it was learned, until something proves it wrong.

The consolidation gate reads the same numbers. A memory graduates toward an expert when it has been reinforced at least twice, stays above 0.50, and is not volatile. An opinion has no executable check, so it needs 0.90.

Forgetting writes a tombstone. Sync carries it everywhere, and a forgotten memory cannot be reinforced back.

One memory's standing
bank

The tokio 1.40 bump hung tests/webhook_retry.rs until the test paused the clock with tokio::time::pause().

Confidence0.78
Reinforced2 × (needs 2)
Graduates Clears the gate: reinforced 2 times, confidence 0.78. Rank score 0.48.
  1. store_memory0.60
  2. reinforce_memory0.70
  3. reinforce_memory0.78

Provenance

Every session checks its memories against your repository.

A memory about code is stored with its repository, commit and branch. At session start, the hook asks git two questions about each one: is the commit on HEAD, and does the branch still exist? The answer tags the memory before your agent reads it.

Nothing is re-extracted and nothing is deleted. A stale memory is shown as stale instead of being silently wrong. Merging a pull request carries what its branch learned onto main.

A memory anchored at 3f9c2a1
main 0d93b4e a41c9e2 3f9c2a1 e5b80c4 fix/webhook-retry HEAD
bankliveconfidence 0.84

The tokio 1.40 bump hung tests/webhook_retry.rs until the test paused the clock.

$ git merge-base --is-ancestor 3f9c2a1 HEAD exit 0: the commit is on HEAD $ git show-ref --verify refs/heads/fix/webhook-retry found: the branch exists

Its commit is on HEAD and its branch exists, so the memory comes back as live.

Compartments

Shared on purpose, and revoked at once.

Memories live in compartments you own. Share one as a reference and the other person can recall it; share it as a link and they can also connect to it. Revoking writes a tombstone, and their next query fails closed.

None of this is a filter in application code. Every call carries a signed token naming a tenant and a user, and the database engine's own row permissions decide what that identity may read.

Antumbra can propose compartments for memories that have none, by clustering them; you decide which to create.

Two people, one engine

You owner

ledger-teamprivate
  • Ledger amounts are stored as i64 cents.
  • Every ledger write takes an idempotency_key.
  • Deploys roll staging first through Argo CD.
personalprivate
  • Prefer paused virtual time in async tests.
  • Explain the why in commit messages.

Dana teammate

Dana asks her agent:

How are ledger amounts stored?

recall_memories("how are ledger amounts stored?") → nothing_cleared_the_floor Your compartments are outside Dana's grant, so the engine never returns them.

Dependencies

Before you change a service, see what it reaches.

Dependencies are recorded with where the claim came from: declared in a manifest, observed in traffic, learned, or claimed by someone. Each source carries its own confidence and fades when nobody records it again. Blast radius walks the strongest paths, up to six hops, and shows the evidence for every one. Pick a service.

Blast radius

ledger-core

  1. ledger-api0.95 · 1 hop · declared in Cargo.toml
  2. payments-webhook0.95 · 1 hop · declared in Cargo.toml
  3. payouts-worker0.95 · 1 hop · declared in Cargo.toml
  4. billing-ui0.85 · 2 hops · via ledger-api
  5. reports-job0.47 · 2 hops · via ledger-api

Also in the store

The rest of what a working memory needs.

  • Typed links between memories

    One memory can reference, supersede, contradict, follow or have caused another, and recall can walk to a memory's neighbors.

  • Handoffs between machines

    Leave a note for your session on another machine. It is announced at that session's start until you mark it done.

  • Documents, kept apart

    Design docs and runbooks are chunked, embedded and recalled separately from episodic memory, and can be private to a compartment.

  • An archive of record

    With Copal attached, the original of every document is stored first and its digest verified; each chunk points back to it.

  • Facts from git itself

    antumbra git-facts derives ownership, hotspots and files that change together from the log, without a parser.

  • Sync between stores

    An embedded store on your laptop and a SurrealDB server sync both ways, last write wins, tombstones included.

What keeps proving true becomes a skill.

Memories that clear the gate are trained into small frozen experts that answer on your own hardware.

Meet the population Try the recall bench