Skip to main content
Carry is a memory layer for AI agents where every answer carries its proof. Most AI-memory projects answer one question: can an agent remember across sessions? Carry answers the harder one — can you prove what an agent used to answer you, and stop it from touching memory it was never allowed to? Every memory-based answer renders a verifiable Answer Receipt — the memories it used, whether each was authorized, whether the blob still resolves on Walrus, and the namespaces it was blocked from. The access policy is enforced at retrieval, so the model physically never sees memory it isn’t allowed to use. And each answer can be anchored on Sui as a tamper-evident Proof object that anyone can verify — with no wallet.

Watch the demo

The real app driven live — GPT-4o + Claude, Walrus testnet, on-chain proof.

Run it locally

Zero to a running, live Carry in a few minutes.

How it works

The gate-before-generation architecture, end to end.

Verify a proof

The walletless public verifier — don’t trust Carry, verify it.

​
The problem

AI agents are getting persistent memory, and that’s the easy half. The hard half is trust. When an agent answers “from memory,” you have no way to know which memory it used, whether it was allowed to use it, or whether that memory even exists where it claims. Memory is locked to one app or model, it doesn’t travel when you switch providers, and “the agent remembered” is something you take on faith. That faith is the problem. An agent with access to a user’s health, billing, and project memory — across multiple models — is one bad retrieval away from leaking something it should never have seen.

​
The design rule

Gate before generation. The agent × namespace policy is enforced at retrieval — the model only ever sees allowed memory — so the receipt under every answer is honest by construction, not a label slapped on after the fact.

​
What you get

Cross-model memory

Teach with one model (GPT-4o), recall with another (Claude). The memory — and its proof — travel with the answer, not the vendor.

Verifiable receipts

Every answer ships an Answer Receipt: memories used, authorization, and a live Walrus blob check.

On-chain proofs

Anchor any answer as a tamper-evident Receipt object on Sui — chained by blake2b256, ownable, permanent.

Works in any agent

An MCP server gives Cursor, Claude Desktop, and Claude Code the same gated, receipted memory.

​
Built on the Sui Stack

Carry is built end-to-end on the Sui Stack — every capability is wired through the real platform, not faked.

​
One vault, every surface

The same gated memory and the same Answer Receipt, everywhere an agent lives:

Aria — the companion

A consumer health companion that only remembers what you allow — and proves it live.

carry — the CLI

npx @usecarry/cli — recall with a receipt, anchor a verifiable proof, from your terminal.

MCP server

npx @usecarry/mcp — gated, receipted memory in Cursor, Claude Desktop, Claude Code.

Vercel AI SDK

withCarryMemory(model) — proof-carrying memory in any AI SDK agent, one line.
Built on Walrus · Seal · Sui for Sui Overflow 2026 (Walrus track).