Memory
Memory with a byline.
Every other agent remembers by eavesdropping. Aghata compiles memory from work that actually finished, shows you every candidate before it's learned, and keeps each entry linked to the run that produced it. You can read all of it.
The claim
If you can't read what your AI learned, you don't control it.
How memory forms
Learned from finished work. Reviewed before it counts.
Memory is compiled, not logged. When a session completes, candidates are extracted from what actually happened — then they earn their way in.
A session finishes; candidates surface
Completed work — not chat transcripts — is distilled into candidate memories: facts, preferences, and procedures that would help next time. Failed runs produce nothing.
Candidates clear a bar
Each candidate is scored against what's already known: near-duplicates reinforce the existing entry instead of multiplying, weak ones are deferred or rejected, and review mode shows you what's pending before it's learned.
Future work starts warmer
Sessions recall relevant entries with their confidence and verification status attached, and show a 'used N memories' chip that links straight into the wiki — so you always know what informed the work.
Wiki & graph
A knowledge base you can open. A graph you can interrogate.
Memory has two readable faces: a wiki of entries you can edit like documents, and a provenance graph that answers 'why does it believe this?'
Readable entries. Every memory is text you can open: what it says, its confidence, whether you verified it, and every session that produced or reinforced it.
Three kinds of edges. Reinforces, conflicts with, derived from. The graph's structure is explicit and auditable — relationships are recorded when they happen, not conjured on render.
Inferred is labeled inferred. Model-suggested similarity is drawn differently from audited provenance. You are never left mistaking a guess for evidence.
Trace the evidence. Select any entry and follow the shortest path back to the task, source, record, or approval that caused it. Belief has an address.
Review mode. Pending candidates render alongside what's already known — you can see what Aghata is about to learn, in context, before it learns it.
Conflicts surface themselves. When a new candidate contradicts an existing entry, it's staged as a conflict for you to resolve — not silently averaged away.
Governance
An auditor's desk, not a black box.
Memory ships with the tools of a records system: queues that surface what needs attention, and verbs that keep history instead of destroying it.
The Auditor knows where to look
Pending candidates. Conflicts. Unverified entries the agent keeps using. Stale entries fading out. Recent auto-promotions worth a spot-check. Attention goes where it matters, not to a scroll of everything.
Edit, verify, merge, split, resolve, archive, restore
Correcting the record is a first-class operation. Merging unions the evidence; editing resets verification; archiving supersedes rather than erases.
Nothing is ever silently deleted
Every change to every memory lands on an append-only ledger with the actor recorded — human or system. The history of what your agent believed, and when, is itself kept.
Team memory is an explicit act
Every memory is born personal. Promotion to Team Memory is deliberate, teammate edits arrive as reviewable proposals, and workspace entries are labeled whenever the model uses them.
The category
Three things people call 'AI memory.'
The word is doing a lot of work in the industry right now. Here's the difference in mechanics.
| Vector-store recall | Chat-log memory | Aghata Memory | |
|---|---|---|---|
| Where it comes from | Whatever documents got embedded | Things you said in conversations | Work that actually finished, distilled |
| Can you read it? | Not meaningfully — it's vectors | A settings list, at best | A wiki and a graph, entry by entry |
| What gets in | Everything indexed, good or bad | Whatever the model found notable | Candidates that pass review and a confidence bar |
| When it's wrong | Re-embed and hope | Delete the line, lose the history | Edit, merge, or resolve — history kept, append-only |
| Why it believes something | Cosine similarity | No answer | A provenance path to the run, source, or approval |
Questions
What people ask about memory.
How is this different from ChatGPT's memory?+
Chat products remember by eavesdropping on your conversations, and you mostly discover what they retained by accident. Aghata compiles memory from finished work — sessions that actually ran — and every candidate passes through review before it's learned. The result is a wiki you can open, not a vibe you can't inspect.
Can I see everything it knows?+
Yes — that's the point. Memory is a readable wiki and a navigable graph. Every entry shows its text, its confidence, whether you've verified it, and the sessions that produced and reinforced it. There is no hidden store behind the visible one.
What if it learned something wrong?+
Open the entry and edit, archive, or merge it — or resolve the conflict when two memories disagree. Nothing is silently deleted: corrections supersede, and the full history of every change stays on an append-only ledger with the actor recorded.
Does it learn from failures?+
No. Only terminal, completed work is eligible, and each candidate clears a confidence bar for its kind before promotion. A run that went sideways doesn't become advice.
How does team memory work?+
Everything is born personal. A memory becomes Team Memory only by explicit promotion, and teammates' edits to shared entries arrive as proposals for review. Workspace memories are labeled when the model uses them, and they never leak into guest or temporary threads.
Chapters of one system
Give it the outcome. Keep the control.
Start free in the product, or talk to us about how your team would use it.