Your agent forgets you the moment a session ends. Agent QA gives it
one memory that follows you: encrypted under your passphrase,
kept on Walrus, recalled by any agent on any device. Wire it in once and
your coding agent, trading agent, or wallet agent picks up where the last
one left off. Yours, not the vendor's.
Your identity
Who this memory belongs to. The passphrase encrypts every note before it
touches storage. It travels only over HTTPS with each call, is used
transiently, and is never stored anywhere. Whoever holds it holds the
memory; lose it and the notes stay sealed forever.
One folder per project. The same identity and passphrase reach the same memory from every agent and every machine.
The console
Rememberencrypt · seal · receipt
encryptingWALRUS
Recallpull · decrypt · rank
Memory fault
Files
Store real files, encrypted under your passphrase, on Walrus, and pull them back on
any machine. Add a single file, or a whole folder (zipped in your browser first). Uses
the identity and folder above.
Filesencrypt · walrus · fetch
encryptingWALRUS
Wire your agent
The same memory through MCP. On a new device, set up once: the passphrase is
typed blind and stored in the operating system's credential store, never in a
config file. Then one line wires any agent, and the identity and passphrase
ride as headers, so the secret never enters the model's context.
new device · one-time setup
npx agent-memory-connect setup
then wire any agent · -s user covers every project on the device
claude mcp add -s user agent-memory -- npx -y agent-memory-connect
Every session opens by recalling the project folder, so the agent continues instead of starting from zero.
02
Remember in the moment
Decisions, preferences, and actions are stored when they happen, with a Walrus receipt for each write.
03
Close with a digest
Before the session ends, one handoff note: what changed, where things stand, what comes next.
>_
MEMORY CONSOLE
encrypted under your passphrase · confirmed on Walrus · recalled by any agent
AGENT·QA DOCS
One memory · every agent
What Agent QA is
A private, portable memory for agents. Encrypted under your passphrase, kept on Walrus, recalled by any agent on any device. Install it once as an MCP server and your agent stops forgetting you.
Agents are stateless. A coding agent forgets the project between sessions; a trading agent forgets its own trades; a wallet agent forgets what it rescued. Whatever memory products exist keep your context inside one vendor, readable by them, unreachable from anywhere else. Agent QA moves the memory to you: your passphrase encrypts every note before it leaves the server's memory, the ciphertext lives on Walrus, and any agent you authorise can recall it from anywhere.
"Memory is quality assurance for agents. An agent that remembers its decisions, its trades, and its mistakes is a better agent every session."
Built for the OKX.AI marketplace
How a note travels
Remember. Your note reaches the memory service with your identity and passphrase. A key is derived from the passphrase, the note is encrypted, and the ciphertext is sealed to Walrus.
Confirm. The reply says stored only after Walrus confirms the write, and carries the blob id as a receipt. A failed write says so; it never pretends.
Recall. A query pulls the folder's ciphertext, decrypts it transiently with your passphrase, ranks it against the question, and returns the best matches. A wrong passphrase decrypts nothing.
Forget. A folder can be retired for good: the service never serves its notes again and the folder starts fresh. Honoured only when the passphrase actually opens the folder.
Folders
Memory is organised as you, then folders, then notes. One folder per project or task keeps recall scoped and fast: your coding agent recalls project-x, your trading agent recalls dex-trading, and neither wades through the other's notes.
Wire your agent
One endpoint, two headers. Any agent that speaks MCP over HTTP carries the memory.
The identity and passphrase ride as HTTP headers set in the client's configuration, never as tool arguments, so the secret never enters the model's context.
The friendly way: set up a device once
The connector stores your passphrase the way passwords should be stored: typed blind, kept in the operating system's credential store (Credential Manager on Windows, Keychain on macOS, libsecret on Linux), never in a config file, an env var, or a shell history.
one-time setup
npx agent-memory-connect setup
It asks for your identity and your passphrase, confirms the passphrase twice, and prints the one line that wires any agent:
wire any agent
claude mcp add -s user agent-memory -- npx -y agent-memory-connect
-s user makes the memory available in every project on the device, which is usually what you want; drop it to wire only the current project directory.
The agent talks to a local proxy; the proxy reads the passphrase from the credential store at request time and attaches the headers. Every agent on the device shares the same memory, and none of them ever sees the passphrase. npx agent-memory-connect status shows what is configured, never the value; reset removes it. A headless server with no credential store is told so and offered a fallback file readable only by that account, written only with an explicit yes.
The sections below wire clients directly with headers instead, which works anywhere without the connector.
From "type it yourself" to "it just happens". Each level is a strict upgrade on the one before, and they compose.
Level 1
Just ask
Plain English in any session. "Recall from agent memory, folder project-x." Or, at the end: "Write a handoff digest to agent memory." The agent maps that to the tools.
Level 2
Let the server ask
Already shipped. The server sends every client the ritual on connect: recall at session start, remember decisions as they happen, digest before the end. Usually one word from you is enough.
Level 3
Make it automatic
A hook. Model behaviour is probabilistic; a hook is not. The text below lands in the model's context at the start of every session, so recall happens with no prompt at all.
Note
Write in the moment
An agent can only write a digest if it is still running when it decides to. Notes written the moment a decision happens survive a crashed session; a digest that never got written does not.
Level 1, just ask. Nothing to configure. In any session with the memory wired:
in the chat
recall from agent memory, folder project-x
Level 2, the server already asks. The memory server ships instructions that every MCP client reads on connect, so the agent knows the ritual without being taught it. This is why a fresh session on a new machine picks up the habit on its own.
Level 3, a hook. Add a SessionStart hook in .claude/settings.json. Its output is injected into the model's context before the session begins, so the first thing the agent does is recall, every time, whether or not it thinks of it.
Point it at https://agentsqa.xyz/mcp over streamable HTTP and attach the two headers to every request. That is the whole integration. Custom agents built on an MCP SDK pass the headers when constructing the HTTP transport.
The session ritual
The server tells every connected agent to work this way; it is what makes the memory reliable rather than occasional.
Start by recalling. First thing in a session, recall with the project as the folder, so the agent continues where any previous session left off.
Remember at the moment it matters. A decision, a preference, a trade placed, a wallet recovered: stored right then, not at the end.
Close with a handoff digest. One note before the session ends: what changed, the state things were left in, what comes next.
Building memory into a single-purpose agent
A trading agent, a wallet agent, or a support agent does not need MCP to carry memory; the REST API is three calls. The pattern that makes it feel right for people who never touch a terminal:
Ask once, like connecting an exchange. The agent's settings screen asks for a memory passphrase in a normal password field, one time, and keeps it in the agent's own secure storage. From then on the user just sees memory connected.
Follow the ritual in code. Recall the strategy's folder on startup, remember every trade or decision as it happens and show the Walrus receipt in the activity log, write one digest on shutdown.
Point users here for trust. This console opens the same memory with the same identity and passphrase, so a user audits what their agent remembered directly instead of taking the agent's word for it. Switch agents tomorrow and the memory comes along.
Using the console
The console on the home screen is the human door to the same memory your agents use. Three fields, two actions.
Identity
Who you are
A stable string that names you, such as an email address. The same identity reaches the same memory everywhere.
Passphrase
The only key
Encrypts every note before storage. Sent only over HTTPS, used transiently, never stored. Lose it and the memory stays sealed.
Folder
One per project
Scopes what you write and what comes back. Leave it empty for the default space.
Receipt
Proof of the write
Remember reports stored only after Walrus confirms, and shows the blob id the note lives under.
Writing notes that recall well
Start with the date. "2026-07-14: chose Caddy over nginx because certificates renew themselves."
Name concrete things: file paths, commands, amounts, addresses, endpoints.
State why, not just what. The reasoning is what the next session actually needs.
If a recall says the folder holds more than could be scanned, treat the answer as possibly incomplete and narrow the query or the folder.
HTTP API
The service is small on purpose. Two routes do the work; the MCP endpoint wraps the same two.
POST /remember
# request body
{
"user_key": "you@example.com",
"passphrase": "your-passphrase",
"content": "2026-07-14: bought 0.5 ETH at 3,842 USDC. Stop at 3,690.",
"folder": "dex-trading"
}
The reply reports stored, and when the write is confirmed it carries receipt, the Walrus blob id. A write that could not be confirmed comes back as stored: false with the reason in note.
POST /recall
# request body
{
"user_key": "you@example.com",
"passphrase": "your-passphrase",
"query": "past trades on ETH and how they went",
"folder": "dex-trading",
"limit": 8
}
The reply carries records, the decrypted best matches, and truncated, which is true when the folder holds more than could be scanned.
Forget retires a folder permanently: no recall returns its notes again, and the folder starts fresh for new writes. It is honoured only when the passphrase actually opens the folder, so an identity string alone cannot wipe anything.
Other routes
GET /health returns a liveness check for hosting and monitoring.
GET / serves this console.
/mcp is the MCP endpoint: tools remember, recall, and forget, identity from the X-Memory-User and X-Memory-Passphrase headers.
FAQ
Who can read my memory?
Whoever holds your identity string and your passphrase, and no one else. Every note is encrypted under a key derived from your passphrase before it reaches Walrus. The operator of this service cannot read your notes; neither can anyone who finds the ciphertext. A wrong passphrase decrypts nothing and returns nothing.
Do I have to put my passphrase in a config file?
No. Run npx agent-memory-connect setup once per device: the passphrase is typed blind and stored in the operating system's credential store, and agents connect through a local proxy that attaches it at request time. Nothing secret ever sits in a config file, an env var, or a shell history. Direct header configuration remains available for environments where the connector is not an option.
What do I need on a new device?
Two things, typed once: your identity and your passphrase. The identity is just an address, like a username; it says which memory to fetch and is not a secret. The passphrase is the only key. After the one-time setup, every agent on that device recalls what any other device stored, with no prompting again.
What if I lose the passphrase?
The memory stays sealed, permanently. There is no reset and no recovery, because a reset path for you would be a reading path for someone else. That is the price of the operator not being able to read your notes; treat the passphrase accordingly.
Can I delete a folder?
You can forget it, and we are precise about what that means. Walrus is immutable storage, so nothing can reach in and erase a written blob; it expires when its paid storage lapses. forget retires the folder instead: the service never serves those notes again, and the folder starts fresh for new writes. The request is honoured only when your passphrase actually opens the folder, so knowing someone's identity string alone cannot wipe anything. The old ciphertext stays sealed under your passphrase until it expires, which is the same reason a lost passphrase is permanent: key destruction is the only true delete on immutable storage.
Where does the memory live?
On Walrus, as encrypted blobs, written through MemWal. Each confirmed write returns the blob id as a receipt, so a note is not just stored but provable. The service in front is stateless; you can point your agents at this one or run your own with the published compose files, and the memory model does not change.
What counts as one memory?
One identity. Folders divide it by project or task, so recall stays scoped: a coding agent reads the project folder, a trading agent reads the strategy folder, and the same person owns both from any device.
Why would my agent actually use it?
The MCP server carries instructions every connected agent reads: recall the folder at session start, remember decisions the moment they happen, close with a handoff digest. Clients with hooks can make the first recall automatic. The tools' own descriptions teach the note style that recalls well.
Is this the same Agent QA that graded MCP servers?
Same name, sharper product. The grading engine still exists in the codebase, but the product is the memory: quality assurance for agents now means an agent that remembers, on every machine, in every session.