Use caseSales

One account memory, however many agents touch it

A rep who has covered an account for two years knows things no CRM field holds. When a fleet takes the work over, that knowledge has to live somewhere every one of them can reach.

01 What breaks

Three agents, three private pictures of one account

The CRM was built to be written by people, one at a time. A fleet writes constantly, in parallel, and mostly about things the schema has no column for.

01

The CRM records outcomes, not reasons

Closed-lost, with a dropdown reason. Why they actually stalled — the reorg, the competing project, the one person who never got comfortable — was said on a call and lives in somebody’s head. The field is filled in and the knowledge is gone.

02

Each agent keeps its own notes

The research agent, the outreach agent and the meeting agent each build a picture of the same account in their own store. Three pictures, no reconciliation, and no way to tell which is stale.

03

A handoff is a summary

Coverage changes and two years compress into a paragraph. Everything not in the paragraph is not handed over — it is discarded, and nobody can tell what was in it.

02 What it’s made of

Mostly shared memory. Then three others.

Every application built on CortexDB is a different mixture of the same five memory jobs. That mixture is what makes this a different piece of software from the one next to it, even though the infrastructure underneath is identical.

Dominant · Shared memory

One memory, many agents

Every agent on the account reads and writes the same scope. Not a synced copy per agent, and not a summary passed between them — one store, with scopes deciding who may see what.

  • No per-agent silos to reconcile.
  • Scoped: shared is not the same as leaked.
  • Handoffs carry context, not a summary of it.
Episodic memory

What was tried on this account

The outreach that worked, the demo that stalled, and why — attached to each other rather than scattered across activity logs.

Persistent memory

The things they told you once

A stated constraint from month one is still in force in month twenty, without anyone re-asking.

Valid time

Who the champion is now

People change roles. The memory records when each fact was true, so an old org chart cannot answer a current question.

That is four of the five. The fifth — decision context, where selection weighs state and validity rather than similarity — leads for research and coding agents instead. Same engine, different mixture.

03 What feeds it

The account’s history is already being recorded

Calls are transcribed, threads are archived, the CRM logs every touch. None of it is currently addressable as one account memory.

01 Wire the sources

Vendor connectors ship as extras on the connector package.

Install
pip install 'cortexdb-connectors[slack,salesforce]'

02 One agent writes

The research agent records something it learned on a call. Note the scope — it is the account, not the agent.

Store an experience
curl -X POST http://localhost:3141/v1/experience \
  -H 'Content-Type: application/json' \
  -d '{
    "scope": "ws:sales/acme",
    "modality": "observation",
    "content": {
      "kind": "text",
      "text": "Procurement freeze until the FY close in March. Champion asked us to re-engage the week after, not before."
    },
    "context": { "observed_at": "2026-08-27T09:14:00Z" },
    "idempotency_key": "tldv:acme:call-2291"
  }'

03 A different agent reads

Same scope, different actor. The outreach agent never spoke to anyone on that call and starts with what was said on it.

Recall it
from cortexdb.v1 import V1Client

# a different agent on the same scope
client = V1Client(api_url="http://localhost:3141", actor="agent:sales-outreach")

pack = client.recall(
    scope="ws:sales/acme",
    query=outreach_brief,
    view="holistic",
    include=["episodes", "facts", "beliefs"],
    budgets={"max_tokens": 1000},
)

reply = llm.respond(outreach_brief, context=pack["context_block"])

pip install cortexdbai or npm i cortexdbai — both ship the same client. Full endpoint reference in the docs.

04 Where it runs

Pipeline data is commercially sensitive before it is personally sensitive

An account memory contains your pricing floor, your loss reasons, and named opinions about named people at customer companies. Most of it would be damaging in either direction if it left.

CortexDB is a single container. It runs on your own hardware, inside your VPC, or air-gapped — with the embedding and generation calls pointed at a local model if nothing may leave at all.

Run it
docker run -d --name cortexdb -p 3141:3141 -v cortexdb-data:/data cortexdb/cortexdb:latest

Deployment options, model routing and the enterprise notes are on the download page.

05 The rest

The same infrastructure, a different mixture

Each of these leads with a different memory job, pulls from a different set of sources, and needs a different call. <a class="ul" href="../index.html">All of them, by job</a>.

Assistant agentspersistent memory Commerce agentspersistent memory AdTechpersistent memory Games & multiplayerpersistent memory Data residencypersistent memory Employee supportvalid time Contract & legal opsvalid time Financial opsvalid time Capital marketsvalid time Healthcarevalid time Customer supportepisodic memory Clinical operationsepisodic memory IT service managementepisodic memory Financial servicesepisodic memory Customer successshared memory Government & defenceshared memory Research agentsdecision context Coding agentsdecision context Voice AIdecision context Observabilitydecision context
Try it

Bring the workflow that gets it wrong.

One command starts a local instance with its own volume. The changelog carries every release behind it.

Download CortexDBRead the changelog