−76.8%
Memory tokens at turn-12 through the closed-API proxy. Full-system incl. extraction tax: +33.5% — missed our own bar by 1.5 pts, published anyway.
own Anthropic bill · 2026-07-08
Text-memory re-prefills your whole context every single turn — so cost climbs the more your agent remembers. amem recalls memory by meaning and returns it as reusable KV: prefill is paid once, recall is near-free. And every memory op — add, supersede, erase — lands on a hash-chained, auditor-verifiable log. The cost curve flattens; the audit trail doesn’t break.
Run the same benchmarks on your own model and your own memory — the 63-test adversarial suite ships in the public repo, and the hostile acceptance suites run on your machine during a pilot. Don’t trust us; rerun them.
No new SDK to learn. Swap the base URL — memory becomes KV-native, per-tenant, and recalled as reusable KV.
from openai import OpenAI # engine (design partners) — run it on your own GPU: # pip install -e ".[selfhost]" → amem kv-serve --model <your-open-model> client = OpenAI(base_url="http://localhost:8001/v1", api_key="…") resp = client.chat.completions.create( model="amem-kv", messages=[{"role": "user", "content": "what did we decide last week?"}], extra_body={"user": "alice"}, # per-tenant memory, recalled as reusable KV ) # prefill is paid once; the next query on alice's memory reuses it — near free.
Your agent's memory changes between sessions: facts get added, superseded, erased. atelya-attest hash-chains that lifecycle, so a silent edit fails verification at the exact record, and a GDPR erasure leaves a marker you can verify. Stdlib-only — three files, zero dependencies: your auditor rewrites the verifier in an afternoon.
| seq | time | op | id | detail |
|---|---|---|---|---|
| 0 | 2026-07-16 | add | a91f | "works at Boeing" [key=employer] |
| 1 | 2026-07-16 | add | b8b9 | "works at Airbus" [key=employer] |
| 2 | 2026-07-16 | flag | a↔b | employer conflict |
| 3 | 2026-07-16 | purge | b8b9 | erasure:sha256:a2f9e0b0 — content removed |
Every output line is verbatim from the recorded walkthrough. One tampered byte fails verification at the exact record.
The three questions buyers actually ask →Text-memory tools own meaning but pay to re-prefill it every turn. KV-cache engines own reuse but have no idea what's relevant. amem is the bridge: semantic recall that returns reusable KV.
Unit = text. Recalled by an external embedder, then re-prefilled into the model every turn.
Recall by meaning (the model's own signal) → return the matching memory's precomputed KV. Residency, eviction & lifecycle live in the memory layer.
Unit = KV chunks. Mechanical reuse by prefix/position — no semantics, no recall by meaning.
We meter avoided prefill; you pay a share of measured savings — the meter ships in the engine (design-partner pilots).
See the measured savings →| tenant | prefill tokens saved | $ saved @ $3/MTok | your 20% share |
|---|---|---|---|
| demo-a | 120.0M | $360.00 | $72.00 |
| demo-b | 75.0M | $225.00 | $45.00 |
| demo-c | 240.0M | $720.00 | $144.00 |
| total | 435.0M | $1,305.00 | $261.00 |
No — and anyone claiming that is overselling. It is tamper-evident: any silent edit fails verification at the exact record. Against rewrite-and-rechain, anchor the root externally — atelya-anchor ships for exactly that, and a forgotten label fails loudly instead of silently passing.
Keep it. If your system can emit a one-event-per-line JSONL log, the attest layer bolts on today — three commands, zero dependencies. You get the chain, GDPR hard-erase with sha256 markers, and auditor exports without replacing anything.
Because they never have to trust us. The verifier is stdlib Python — an auditor rewrites it in an afternoon and reruns the 63-test adversarial suite straight from the repo. We publish our benchmark misses in the changelog. Certifications are roadmap; verifiability ships now.