“Why did we decide that?”
The reason lived in a chat that closed. Now someone has to guess, or decide it all over again.
the brain: Teach it once. Every AI remembers.
The ConvOps brain is shared memory for AI agents. Decisions, reasons and where things live are saved as your team works, so the next chat, in any AI tool, starts knowing them instead of starting from zero.
recall before acting · capture on the way out · nothing stored without you
new request
team brain
empty chat · no history
in short
How do AI agents share memory in ConvOps?
Through the brain: decisions, reasons and where things live are saved as the team works, and one recall call brings them back at the step that needs them.
ConvOps is the operations layer for AI agents: an MCP server that holds your team's process as workflows, with approval gates, a shared memory and an audit trail. It runs no AI models.
key facts · october 2026
- One context_query call returns memories, routes (where code and documents live) and related tasks.
- Recall happens where you write it into a step, for example "recall first" at the start of a bug fix.
- Automatic capture is three settings, off by default. Nothing is stored unless you or a step asks for it.
- One recall searches every workspace you belong to, while each memory stays owned by exactly one workspace.
- The memory is the same for every MCP client, so a decision saved from Claude Code is recalled in Cursor or ChatGPT.
best for
- Teams tired of re-explaining the same decisions to every new chat.
- Several people and several AI clients working on the same codebase or process.
- Keeping what a person knew when they leave the team.
not for
- Personal chat memory about you. ConvOps remembers how the work is done, not your preferences.
- A general vector database for your application. The brain serves agents working through ConvOps.
updated
the problem
Every new chat starts from zero.
Your team already made the decision, found the files and learned the lesson. Then the chat closed.
“Where is that code again?”
Every new session re-searches the same files and re-asks the same questions.
“What happens when someone leaves?”
What they knew walks out with them. The AI never learned it in the first place.
watch it work
One decision, two tools, zero re-explaining.
The same change, asked in Claude Cowork on Monday and picked up in Codex on Thursday.
01you, in Cowork
A request becomes a task.
Someone asks for a change from Claude Cowork. ConvOps turns it into a task with a workflow, so the work has a home before anyone touches it.
Can we restyle the checkout page?
task created · Checkout restyle · workflow attached
taskCheckout restyle
look first
build
approveapproval
ship
02the AI
The AI looks first.
Before it acts, it asks the brain: what do we already know, and where does this live? One question, ranked answers.
ask checkout restyle
memoryBrand colours come from tokens, never hex
routeCheckout UI: web/components/checkout/
taskCheckout redesign (done)
03the AI
It learns where things are.
Once it finds the right files, it saves a route: a short note that says where this kind of work lives.
- web/
- components/
- checkout/
- CheckoutButton.vue
- Summary.vue
- account/
- api/
route savedCheckout UI lives in
web/components/checkout/04you approve
You decide. The reason is kept.
You approve the change: keep the button green. That decision is saved as a memory, with the reason, linked to the task.
waiting for you
Keep the checkout button green?
Change itKeep green
05a teammate, in Codex
A new tool, an empty chat.
Days later a teammate opens Codex. A fresh chat with no history. The chat is empty. The brain is not.
empty chat · nothing pasted in
team brain
decisionButton stays green
routecheckout/ lives here
lessonColours come from tokens
06the AI
Right the first time.
It recalls the route and the decision, opens the right files, and keeps the button green. Nobody explained it twice.
Make the checkout page match the new brand.
recall · 2 memories · 1 route
Opening
checkout/CheckoutButton.vue. The button stays green: team decision, red tested worse.checkout
Pay now
Can we restyle the checkout page?
task created · Checkout restyle · workflow attached
taskCheckout restyle
look first
build
approveapproval
ship
the loop
Look first. Work. Keep what you learned.
Every run asks before it acts and saves on the way out. So the next run starts ahead.
recallask the brain
workright files
decideapproval
capturememory + reason
next runstarts ahead
what it remembers
What, where, and why.
Memories: the what
Decisions, lessons and corrections, each with its reason. Ranked by meaning, importance, recency and use.
why we did it
Routes: the where
A map of where the code, docs and data live, so no session has to search for them again.
where it lives
Linked to the work
Every memory points back to the task that produced it. The reason and the work never drift apart.
traceable
Kept healthy
Duplicates consolidate on demand. Forgetting is soft and can be undone. You choose what gets saved.
no noise
try it
Ask the brain.
One question returns the decision, the place to look and the related work, ranked.
try a question
askCan we change the checkout button colour?
#1memory
Keep the checkout button green. Red tested worse on conversion.
meaning
importance
recency
use
#2route
Checkout UI lives in web/components/checkout/
meaning
importance
recency
use
#3task
Checkout redesign
meaning
importance
recency
use
example data · ranked by meaning, importance, recency and use
across teams
One question. Every workspace.
Search spans every workspace you belong to. Each memory stays owned by its own team.
one question
What did we decide about refunds?
Supportworkspace
Financeworkspace
Productworkspace
the difference
Re-explaining vs remembered.
- Paste the same context into every session
- The fix is in a chat log somewhere
- The agent re-greps the codebase every run
- Knowledge leaves when the session ends
- Each workspace is a silo you query separately
Recall is one call
A step that says "recall first" returns memories, routes and related tasks in a single query, before the agent touches anything.
payload
{
"context_query": "payment webhook 500",
"returns": {
"memories": ["X-Sig header moved in v2"],
"routes": ["api/payments/webhook.py"],
"tasks": ["related: webhook retries"]
}
}Capture rides the step
Advancing a step can carry the decision and the why. A require_context gate makes it mandatory. Automatic capture is a set of org toggles that ship off.
payload
{
"workflow_advance": {
"context": "root cause: X-Sig header
moved in v2. Fixed in webhook.py"
},
"org_settings": {
"brain.auto_memory_progress": true,
"brain.auto_memory_decisions": false
}
}Semantic task search
Tasks are searched by meaning, with a fallback when the index is down, plus structured filters and timezone-correct due and overdue views.
Search spans, ownership does not
Recall fans out across every workspace you belong to. Each memory stays owned by its workspace, and every write lands in exactly one.
questions
Agent memory questions, answered.
Is this RAG over my documents?
No. This is operational memory: what past runs learned, what was decided and why, and where things live. Recall is ranked by semantic relevance, importance, recency, and how often a memory earns its keep, not by document similarity alone.
What gets stored automatically?
Nothing you did not choose. Passing context on a step advance stores a memory deliberately; a require_context gate makes recording the why mandatory for that step; and org-level auto-capture toggles exist but ship off by default.
What is the difference between memories and routes?
Memories are WHAT: decisions, learnings, corrections. Routes are WHERE: a semantic map of files, modules, and docs. One context query returns both, plus related tasks, so the agent neither re-derives knowledge nor re-explores the territory.
Does memory get noisy over time?
It can, so hygiene is built in: consolidation dedupes a noisy category on demand, and forgetting is a soft, reversible operation rather than a destructive delete.
Does recall cross workspaces?
Search does; ownership does not. One query fans out across every workspace you belong to, but each memory stays owned by its workspace and isolated at the database layer, and every write lands in exactly one.
Is task search keyword or semantic?
Semantic. Every task is indexed and searchable by meaning, with an automatic fallback when the search index is unavailable, plus a full structured filter surface: dates, hierarchy, status, and timezone-correct due and overdue views.