Why you can't just build it
Rolling your own starts as a JSON file and turns into source sync, retrieval tuning, lineage, deletion, and eval work. That is a platform surface, not a weekend helper script.
Every agent client becomes an integration surface.
A local script can write a few memories. Keeping Claude Code, Cursor, CLI runs, API keys, schema drift, retries, and source changes aligned becomes the product you now maintain.
Search quality is not one embedding call.
You need library scope, metadata filters, citations, source freshness, supersession, and answer-time evidence. Without that, memory becomes a pile of stale snippets.
You still need to prove what the agent used.
The hard part is not storing text. It is showing what was recalled, what was skipped, what changed, and where the memory layer needs correction.
Developer how-it-works
The developer path is concrete: register the MCP server, sync local agent transcript memory, ask through the MCP tool, and inspect the source records when an answer needs proof.
Add the same server to Claude Code, Cursor, or any MCP client.
{
"mcpServers": {
"answer-engine": {
"command": "npx",
"args": ["answer-engine-mcp"]
}
}
} Import new Claude Code transcript turns into a personal memory library.
ae auth login
ae sync run --source claude-code --library personal-memory Ask from the client and keep the cited answer tied to the same library.
{
"tool": "ask",
"arguments": {
"question": "What did we decide about the import rollback?",
"librarySlug": "personal-memory",
"retrievalMode": "hybrid",
"responseStyle": "cited"
}
} ae search "import rollback decision" --library personal-memory --include summary,metadata
ae get <content-id> --include content,metadata,artifacts --library personal-memory Inspectable, portable, yours
The wedge is not a generic memory claim. It is a memory layer a developer can query, inspect, move across clients, and delete from when the source should be forgotten.
Inspectable
Memory is tied back to source items, tags, and recalled evidence so a developer can debug the answer path instead of accepting a black box.
Portable
The MCP server gives multiple agent clients the same memory layer. Your context should not be trapped inside one IDE or one model account.
Yours
Tenant boundaries, no training on your data, and right-to-erasure make memory feel like infrastructure you control, not a feature toggle elsewhere.
Honest
Available-now and shipping-next claims are split on the page. Roadmap work stays labeled until it is actually live.
Not native model memory
Native model memory is single-app and opaque. Answer Engine is cross-source, cross-agent, inspectable, and portable, so the memory follows the work instead of disappearing into one provider's account.
Convenient, but trapped in one surface.
The developer usually cannot inspect the retrieval trail, share it across clients, or decide exactly which source should supersede older memory.
Portable context for the agents you already use.
MCP keeps the client edge open while the memory layer preserves source scope, lineage, and deletion paths across Claude Code, Cursor, Codex, and CLI workflows.
Right-to-erasure is a feature
Personal agent memory should be easy to add and possible to erase. Answer Engine treats deletion, tenant isolation, and no-training boundaries as part of the developer experience, not an afterthought.
Memory must be reversible.
If a transcript, document, or project source should no longer inform the agent, the memory system needs a clear erasure path and a security model that does not reuse your data for training.
Open source where the agent touches it
The open-source surface is the installable edge: the MCP server and CLI. The hosted engine, index, and billing are managed, so portability does not depend on pretending the whole service is open.
@answer-engine/mcp-server
The MCP package exposes Answer Engine to Claude Code, Cursor, Codex, and any compatible client through the same install line.
View open-source split@answer-engine/cli
The CLI handles auth, sync, search, import, and inspection from the terminal so developers can keep memory workflows scriptable.
Read open-source splitWhat is shipping next stays labeled
These are not available-now promises. They are the developer-facing roadmap items that make portable memory easier to operate over time.
Give your agent a memory layer you can inspect.
Start with the MCP install, keep your personal workflow free of pricing friction, and move memory across clients as your stack changes.