Run 40 beats run 1.
The loop recalls before it acts and captures on the way out. Memories hold what past runs learned; routes hold where things live. One query returns both, plus the related tasks, so no run starts from zero.
Memory for AI agents is not a vector store bolted onto a chat. It is the difference between a loop that starts every run from zero and one that arrives already knowing what the last thirty-nine runs learned. Without it, agents re-explore the same codebase, re-ask the operator the same questions, and re-make decisions that were already made, and every session's hard-won context evaporates when the window closes.
ConvOps ships the brain as tools your workflow wires in deliberately, not as magic that happens to you. A step that says "recall first" gives the agent memories (what past runs learned), routes (where the code and docs live), and semantically related tasks, all in one query, before it acts. On the way out, advancing a step can carry the decision and the why, stored as a memory linked to the task. Nothing is captured without you choosing it: mandatory capture is a gate you place, automatic capture is a set of org toggles that ship off.
The result is compounding: the tenth run of your content pipeline knows the style rulings, the failed approaches, and the file layout that the first run had to discover. That is why run 40 beats run 1, and why the loop gets cheaper and sharper the longer it lives.
One call, full context.
Write "recall first" into a step and the agent gets memories, routes, and semantically related tasks in a single query, before it touches anything. No re-exploring the codebase, no re-asking the operator.
{
"context_query": "payment webhook 500",
"returns": {
"memories": ["X-Sig header moved in v2"],
"routes": ["api/payments/webhook.py"],
"tasks": ["related: webhook retries"]
}
}Memories are WHAT. Routes are WHERE.
Memories carry knowledge: decisions, learnings, corrections, ranked by relevance, importance, recency and use. Routes are a semantic map of where things live: files, modules, docs. Together they are why the agent stops asking questions it already answered.
- Importance-weighted recall, organised by category
- Consolidation dedupes a noisy category on demand
- Forgetting is soft and reversible
Captured on the way out. Nothing stored without you.
Advancing a step can carry context: the decision and the why, stored as a memory linked to the task. A require_context gate makes it mandatory. Org toggles control automatic capture, and they are off by default.
{
"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
}
}Ask your task graph anything.
Task search is semantic, not substring. Structured filters, date ranges, hierarchy traversal, timezone-correct due and overdue views, and atomic bulk updates sit behind one query surface your agent can actually use.
- Semantic search with automatic fallback when the index is down
- Counts and aggregates for dashboards
- Explicit timezone on every due/today/overdue view: no server-local guessing
One recall across every workspace.
Recall fans out across every workspace you belong to in a single query, so context is never siloed. Writes always land in exactly one. Each workspace keeps its own memories, isolated and owned.
Re-prompting vs remembering
| without a brain | with recall wired in |
|---|---|
| Paste the same context into every session | One query returns it, ranked and current |
| The fix is in a chat log somewhere | The decision is a memory linked to the task |
| The agent re-greps the codebase every run | Routes already say where things live |
| Knowledge leaves when the session ends | Capture is wired into the step that produced it |
| Each workspace is a silo you query separately | One recall searches every workspace you belong to |
questions
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.