Memory that your team can operate, not just deploy.
Most memory tools optimize for retrieval quality. MemexAI optimizes for operability — memory that is scoped per user, correctable by your team, and auditable when something goes wrong.
The difference is what happens when memory is wrong.
Retrieval-first memory is hard to debug when it fails — wrong extraction, retrieval miss, or retrieval ignored. MemexAI separates those failure modes by keeping memory as auditable files with full revision history and access logs.
Memory should be correctable
Wrong facts should be editable by your team — not buried in a retrieval index. MemexAI stores memory as files your ops team can open, fix, and verify.
Memory should be auditable
Every read and write is logged with a tool call ID. Every file change creates a revision. You can trace any behavior back to the exact memory state that caused it.
Memory should be scoped
Per-user memory is physically isolated. Shared guidance is separate from user facts. Agents never cross tenant boundaries by design.
Per-user memory that your ops team can inspect and fix
The problem
When an agent behaves differently for two users, you need to understand why. Most memory tools give you a retrieval API, not a correction surface.
How MemexAI solves it
MemexAI scopes memory per tenant with physical path isolation. Every write creates a revision. Your support or ops team can open a user's memory files, fix wrong facts, and see exactly what the agent learned and when. Memory becomes a product data surface you operate, not a black box you deploy.
Project-scoped memory that outlives a context window
The problem
Code agents forget architectural decisions, learned API quirks, and recurring error patterns between sessions. Re-discovery is slow and expensive.
How MemexAI solves it
Store project-level facts in structured memory files: API constraints, stack preferences, common failure modes, previous decisions. The agent carries forward what it learned — not just the prompt, but the accumulated working knowledge for this specific repository.
Memory that carries context across tickets and sessions
The problem
Support agents ask users the same questions session after session. Memory that doesn't persist forces users to repeat themselves and agents to re-establish context from scratch.
How MemexAI solves it
MemexAI stores stable user facts — product tier, integration setup, known issues — in durable memory files. Each session inherits what the previous one learned. When a fact becomes wrong, support staff correct it directly. Memory stays in sync with the user's actual situation.
Task state that survives across context resets
The problem
Complex tasks that span days or weeks lose intermediate state when context windows reset. Agents restart from scratch, repeat completed steps, and miss learned constraints.
How MemexAI solves it
Write task checkpoints, completed sub-goals, and learned constraints into memory files as the agent works. On resumption, the prompt block injects current task state before the first tool call. The agent continues from where it left off, with all hard-won context intact.
Shared behavioral context across agents in a product
The problem
When multiple agents handle different parts of a product, coordination policies live in prompts. Changing policy means updating every agent's system prompt and redeploying.
How MemexAI solves it
MemexAI's shared memory layer provides read-only guidance all agents in your deployment receive automatically. Tool rules, escalation criteria, API limits, and coordination conventions live in one place. Change a shared file and every agent's next call reflects the update — no deployment needed.
Memory you can debug without guessing what the agent learned
The problem
Debugging personalization failures is hard when memory is a vector index. You can't tell if the agent failed to write, failed to retrieve, or retrieved and ignored.
How MemexAI solves it
MemexAI's audit surface separates the failure modes. Access logs show every read and write with tool call IDs. Revisions show every version of every file. You can reconstruct exactly what the agent knew at any point in time and trace wrong behavior back to its cause.
Pick the integration path that matches your stack.
MemexAI works in two modes that share the same Postgres schema and tool API. Choose direct Postgres for full control, or the Docker service for multi-tenant isolation with an admin UI out of the box.
Direct Postgres
Your app owns the database connection. No HTTP layer. Import @memexai/core, call migrate() once, and wire memory tools directly into your model call.
Read the docsDocker service
Run the MemexAI service alongside your app. Clients use @memexai/sdk with an API key. Postgres, the service, and the admin UI all start from one compose file.
Read the docsAgent onboarding
Hand a coding agent the setup file at memexai.space/setup.md and it wires MemexAI into your existing agent project — detecting your stack and adding the right adapter.
Read the docsAdapters for the frameworks your agents already use.
MemexAI ships adapters for Vercel AI SDK, Anthropic SDK, LangChain, OpenAI, LlamaIndex, CrewAI, and Google ADK — in TypeScript and Python. You keep your existing model SDK and add memory at the agent boundary.