The proof layer for AI memory
Carry lets AI agents share memory across models — and gives users a verifiable receipt for every answer: what memory it used, whether it was allowed, and where it lives on Walrus.
Carry lets AI agents share memory across models — and gives users a verifiable receipt for every answer: what memory it used, whether it was allowed, and where it lives on Walrus.
Carry is designed from the ground up so every answer can be traced to the exact memory it used — and proven against what it was never allowed to touch.
Access is enforced at retrieval. The model only ever sees memory it is allowed to use — receipts are honest by construction.
Teach one agent and recall from another — even on a different provider. Memory follows the user, not the vendor.
Every memory-based answer carries a receipt — memories used, namespaces, source agent, and a Walrus reference, verified.
Stop trusting that an agent used the right memory. Carry renders a structured receipt under every answer — the memories it used, and the namespaces it was never allowed to touch.
Answer Receipt
agent-b · claude
Memory used
Prefers vegan meals
Is building “Carry”
Blocked by policy: health
never retrievedAnchored on Walrus
blob:0x7d3e…ff90
No black boxes. The whole loop is built around one principle: enforce access before the model ever sees a thing.
Agent A captures facts into namespaces as you chat.
A policy check runs before retrieval: agent × namespace.
The answer renders with a receipt of what it used.
Store the receipt as a Walrus blob — verifiable from then on.
“We believe AI memory should be owned, auditable, and provable by the people who actually live with it — not locked inside a model.”
A verifiable memory layer: gate-before-generation, answer receipts, and Walrus-anchored provenance for cross-model AI agents.
Flip an agent’s namespace off and it truly loses access — the gate returns nothing.
A simple agent × namespace grid that controls what every agent can touch.
Receipts resolve and verify against Walrus blobs. Tamper-evident provenance.
Memory belongs to the user, not the model. Portable, auditable, revocable.
We are precise about what is live today versus what is on the roadmap. Here is exactly where Carry is headed.
Working end-to-end in the demo.
Launch the demoIn active progress.
Follow alongThe long-term frontier.
Read the visionStill unsure? We use precise language about what is enforced today versus what is on the roadmap — the honesty is the point.
Want specific guidance? Reach out.
Contact usToday revoke is enforced before retrieval in Carry’s access layer — the gate never fetches a revoked namespace. Seal-based per-agent cryptographic enforcement, so even a leaked delegate key cannot read a revoked namespace, is on the roadmap.
By default every memory is a public Walrus blob, and each answer re-checks that those blobs still resolve — so the receipt’s “verified” badge is real, not cosmetic. You can also anchor the full Answer Receipt as its own Walrus blob for tamper-evident provenance. Carry also ships a MemWal (Walrus Memory) mode that stores memory Seal-encrypted via the Walrus Memory SDK.
Yes. Agent A and Agent B can run on different model providers and still share the same gated memory — the proof travels with the answer, not the vendor.
Access is checked at retrieval, before the model sees anything. The model only ever receives memory it is allowed to use, so the receipt is honest by construction.
Most memory tools just store and recall. Carry adds a gate before generation and a verifiable receipt for every answer — control what each agent can use, and prove it.
Walk the live demo: teach an agent, switch models, revoke a namespace, and watch the receipt tell the truth.