ByteDesk Agent Memory is durable, permissioned, shared memory for AI agent workforces. Agents remember what they learned, departments share what they know, and the organization builds a knowledge base that compounds — with strict server-side boundaries so nothing leaks across trust lines.
We answer every customer within one business hour. Escalate anything legal…
Page the duty agent via the incident stream, then annotate initiative:sev-review…
Open with the customer's own usage wins — pull customer:<id>:notes first…
Refund tool times out on orders older than 90 days — batch them instead…
—
denied server-sideAn agent re-learns the same facts every conversation. Departments can't share what they know. Organizational knowledge lives only in prompts. And any naive shared store leaks private context across agents and teams. A flat vector database is not a memory model — it's a leak waiting to happen.
The access decision is made in the service on the verified caller identity — never by the model, never by the client. An agent can never address another agent's private memory, and a model can never talk its way across a boundary.
The shared brain. Every agent in the deployment can read and write it — charters, runbooks, org-wide facts that every conversation should know.
Team knowledge, members only. Playbooks, tactics, and lessons that belong to one department stay inside it — gated on the caller's verified membership.
Private to each individual agent. Personal lessons, working notes, and preferences no other agent can address — by construction, not by convention.
A per-client shared brain that cross-cuts ownership: what support learned this morning, sales can use this afternoon — readable across departments.
Working memory for a goal that persists across turns and contributors — many agents, one initiative, one accumulating context.
"An agent can never address another agent's private memory, and the model can never talk its way across a boundary."
Org chart, charter, runbooks — stable names every agent can rely on. Resolution walks agent → department → org, most-specific wins: one mechanism for both personal overrides and organizational defaults.
agent:runbook:oncall
This agent's personal override — checked first.
dept:success:runbook:oncall
The team's version, if no personal override exists.
org:runbook:oncall
The organizational default every agent falls back to.
Hybrid vector + keyword search scoped to a compartment — an agent recalls by meaning, and only within memory it's allowed to see. Alongside search: keyed slots, append streams, and prefix browsing.
Vector similarity plus keyword match inside a single compartment. Recall never widens the caller's authority — the scope resolver bounds every query before the engine sees it.
Keyed slots for facts with one true value. Append streams for logs and running context. Prefix listing to walk a compartment like a directory.
SDK helpers write a completed agent turn into memory after the fact — never throwing, never blocking the hot path. A failed capture costs a memory, not a conversation.
Context providers prepend relevant memory to the next turn automatically — the agent starts every conversation already knowing what the organization knows.
Every surface resolves through the same core, so tier authorization is identical however a caller arrives.
An embedded MCP server at /mcp. Any MCP-capable agent or runtime connects and immediately holds the full memory surface — reads, writes, semantic recall, and the well-known index — with its authority decided server-side.
A clean HTTP API under /v1/memory/* and /v1/well-known/* with a consistent response envelope, OpenAPI description, and bearer-key auth. If it can make an HTTP request, it can remember.
The ByteDesk.AgentMemory.Client package ships a typed IAgentMemoryClient plus the capture and recall helpers: a turn capturer that files what the agent just learned, and a context provider that briefs it before the next turn. Both are best-effort by contract — they never throw into your agent loop.
The service scales horizontally; all state lives in the bundled memory engine — a vector + page store shipped as a pinned, product-owned image. Embedded store for development, PostgreSQL + pgvector for production.
Read the quickstartDeploy inside your own boundary, hand your agents the MCP tools, and watch organizational knowledge accrue from the first conversation.