What DIN can read
DINCTRL grades claims against the evidence that produced them - so the evidence must still exist. Tools that keep the original conversation (Zep/Graphiti, Letta, LangGraph, OpenAI Sessions, AWS AgentCore events, Azure Foundry conversations, Google Agent Engine, Supermemory, Khoj, Basic Memory, SpecStory, and the Claude Code, Codex, Gemini CLI, Qwen Code and Cline-family transcripts) can be graded once they are imported (the rows marked IMPORTS TODAY below import today), every grade resolving back to a specific message or episode by ID. Tools that store only extracted facts cannot be graded, because the thing a grade would point at is gone (Mem0 hosted, Vertex Memory Bank, Azure Foundry Memory, AWS memory records, ChatGPT memory, Claude.ai memory, LangMem, the MCP memory server, projectmem). Verified at the schema level: none stores a pointer back to the turn that produced the fact. That is not a criticism - they recall, they don't adjudicate. DINCTRL sits beside them: we ingest the same source conversations and grade the claims. Writing graded records back into those tools is not in this release.
What works with each agent and source today
One row per agent or source, one column per thing DIN does with it. Importing is not grading. Grading runs on your own inference, on any of three paths: your assistant CLI (Claude Code or Codex), your own API key (Anthropic, OpenAI, or any OpenAI-compatible endpoint) or a local model (Ollama, vLLM, llama.cpp). Claude Code is the path DIN's grading was measured on. The Codex, key and local paths are built and tested on stand-ins; none of them has been validated against a real vendor yet. Grading on the Google Gemini CLI is turned off, because DIN cannot lock its tools down. DIN forecasts the cost first and never caps a run for cost (a cap you set holds). Placement with no model call at all covers live capture, the claude.ai export and Zep / Graphiti.
| source | live capture | history import | free placement (no model call) | recall into the agent | grading backend | spend cap | enterprise fleet |
|---|---|---|---|---|---|---|---|
| Claude Code | yes, on a paid plan: the DIN plugin's hooks, and the sweep over its transcripts | yes: din import --source claude-code | yes: captured sessions are placed observed-only | yes: the plugin's prompt hook and /din | your own inference: the Claude Code CLI (validated), the Codex CLI, your own API key (Anthropic, OpenAI or any OpenAI-compatible endpoint) or a local model (Ollama, vLLM, llama.cpp), these three built and not yet validated against a real vendor | only one you set: din grade on --daily-cap, din import --max-spend; none on --via; nothing is billed per call on Codex or a local model | yes: Claude Code managed settings |
| claude.ai and Claude desktop chats | no: a data export | yes: din import claude-ai <the zip> | yes: placed ungraded | no: din recall in a terminal | your own inference: the Claude Code CLI (validated), the Codex CLI, your own API key (Anthropic, OpenAI or any OpenAI-compatible endpoint) or a local model (Ollama, vLLM, llama.cpp), these three built and not yet validated against a real vendor, with --grade | only one you set: din import --max-spend; none on --via; nothing is billed per call on Codex or a local model | no |
| Cursor | yes, on a paid plan: Cursor's own hooks.json | no | yes: captured sessions are placed observed-only | yes: DIN's recall hook, once wired | your own inference: the Claude Code CLI (validated), the Codex CLI, your own API key (Anthropic, OpenAI or any OpenAI-compatible endpoint) or a local model (Ollama, vLLM, llama.cpp), these three built and not yet validated against a real vendor | only one you set: din grade on --daily-cap; nothing is billed per call on Codex or a local model | no |
| OpenCode | yes, on a paid plan: OpenCode's plugin API | no | yes: captured sessions are placed observed-only | yes: DIN's recall plugin, once wired | your own inference: the Claude Code CLI (validated), the Codex CLI, your own API key (Anthropic, OpenAI or any OpenAI-compatible endpoint) or a local model (Ollama, vLLM, llama.cpp), these three built and not yet validated against a real vendor | only one you set: din grade on --daily-cap; nothing is billed per call on Codex or a local model | no |
| Codex CLI | yes, on a paid plan: the capture sweep over its sessions | yes: din import --source codex | yes: din import --ungraded places it with no model call | yes: its hook and AGENTS.md, once wired | your own inference: the Claude Code CLI (validated), the Codex CLI, your own API key (Anthropic, OpenAI or any OpenAI-compatible endpoint) or a local model (Ollama, vLLM, llama.cpp), these three built and not yet validated against a real vendor | only one you set: din import --max-spend; none on --via; nothing is billed per call on Codex or a local model | no |
| Gemini CLI | no | yes: din import --source gemini-cli | yes: din import --ungraded places it with no model call | yes: its hook and GEMINI.md, once wired | your own inference: the Claude Code CLI (validated), the Codex CLI, your own API key (Anthropic, OpenAI or any OpenAI-compatible endpoint) or a local model (Ollama, vLLM, llama.cpp), these three built and not yet validated against a real vendor | only one you set: din import --max-spend; none on --via; nothing is billed per call on Codex or a local model | no |
| Qwen Code | no | yes: din import --source qwen | yes: din import --ungraded places it with no model call | no: din recall in a terminal | your own inference: the Claude Code CLI (validated), the Codex CLI, your own API key (Anthropic, OpenAI or any OpenAI-compatible endpoint) or a local model (Ollama, vLLM, llama.cpp), these three built and not yet validated against a real vendor | only one you set: din import --max-spend; none on --via; nothing is billed per call on Codex or a local model | no |
| Cline, Kilo and Roo | no | yes: din import --source cline (or kilo, roo) | yes: din import --ungraded places it with no model call | no: din recall in a terminal | your own inference: the Claude Code CLI (validated), the Codex CLI, your own API key (Anthropic, OpenAI or any OpenAI-compatible endpoint) or a local model (Ollama, vLLM, llama.cpp), these three built and not yet validated against a real vendor | only one you set: din import --max-spend; none on --via; nothing is billed per call on Codex or a local model | no |
| claude-mem | no | yes: din import --source claude-mem | yes: din import --ungraded places it with no model call | no: din recall in a terminal | your own inference: the Claude Code CLI (validated), the Codex CLI, your own API key (Anthropic, OpenAI or any OpenAI-compatible endpoint) or a local model (Ollama, vLLM, llama.cpp), these three built and not yet validated against a real vendor | only one you set: din import --max-spend; none on --via; nothing is billed per call on Codex or a local model | no |
| ChatGPT conversations | no: a data export | yes: din import --source chatgpt --export <the zip> | yes: din import --ungraded places it with no model call | no: din recall in a terminal | your own inference: the Claude Code CLI (validated), the Codex CLI, your own API key (Anthropic, OpenAI or any OpenAI-compatible endpoint) or a local model (Ollama, vLLM, llama.cpp), these three built and not yet validated against a real vendor | only one you set: din import --max-spend; none on --via; nothing is billed per call on Codex or a local model | no |
| Grok (X data archive) | no: a data export | yes: din import --source grok --export <the zip> | yes: din import --ungraded places it with no model call | no: din recall in a terminal | your own inference: the Claude Code CLI (validated), the Codex CLI, your own API key (Anthropic, OpenAI or any OpenAI-compatible endpoint) or a local model (Ollama, vLLM, llama.cpp), these three built and not yet validated against a real vendor | only one you set: din import --max-spend; none on --via; nothing is billed per call on Codex or a local model | no |
| Zep and Graphiti | no | yes: din-import-graphiti | yes: no model call | no: din recall in a terminal | none: records keep the regime their source shows | not needed: no model call | no |
| Any MCP client (the hosted DIN connector) | receipts the agent files itself, on hosted DIN (set up with you) | no | yes: a receipt is graded by its evidence, no model call | on hosted DIN, when you grant it (set up with you) | none: no model call | not needed: no model call | no |
| GitHub Copilot | no | no: no mapper | no | no: din recall in a terminal | none: nothing is imported | not needed: nothing is read | no |
| Windsurf | no | no: no mapper | no | no: din recall in a terminal | none: nothing is imported | not needed: nothing is read | no |
| Any other agent runtime | no | no: no mapper | no | yes: it reads the field over its HTTP API with the field token, and a person can stamp a record | none: DIN grades only what it imports or captures | not needed: no model call | no |
Any other agent runtime can read the field over its HTTP API with the field token, and a person can stamp a record. The agent needs a GET, over HTTPS through a proxy you put in front, with no plugin and no MCP server: the any-agent path. It is tested with curl and was run once by hand from a ChatGPT agent; every other runtime should work and is not tested.
din-import-graphiti). Importing reads the source; grading what was imported needs a model,
and the table above says which one, per source. Every row marked otherwise is a format that has been read
at the schema level and a mapper that has not shipped yet, and it is marked that way rather than listed
as support. The order below is the order they
are being built in, and who asks moves it.din field activate
<agent> switches which). Several agents on one field at once is a paid feature.The evidence survives
Their own store keeps the conversation, so a grade resolves back to a specific message or episode by ID. These are ingested as evidence; the grade comes from the model in the table above.
~/.claude/projects/<cwd>/<session>.jsonl, with each subagent's own file beside it.
Tool calls and tool results are present verbatim, so a record out of it is graded logged and its
experiments are direct output rather than a summary of one.~/.codex/sessions: full tool input and output, plus the session's own
working directory and git state. din import --source codex.~/.gemini/tmp. Tool results are untruncated, which makes it the
cleanest non-Claude source. din import --source gemini-cli.~/.qwen/projects. din import --source qwen.din import --source cline
(or kilo, or roo).din import --source claude-mem.din import --source grok --export
<the zip>.din import --source chatgpt --export
<the zip>.--grade
grades them on Claude (your Claude Code sign-in or your Anthropic key), as inferred, because the export
carries no tool results that can be checked. din import claude-ai <the zip>.din-import-graphiti reads
a Graphiti server you run, or Zep's, makes no model call, and ships in the download.Only the extracted fact
Checked at the schema level: not one of them stores a pointer back to the turn that produced the fact. A grade needs the thing it points at to still exist, so we decline these as evidence and say so rather than importing them and calling the result graded.
Graded records, back out
The other direction. A record DIN has graded can be written where your tools already look, anchored rather than pasted. None of the three is shipped yet.
The rule that decides which column a tool lands in
Every vendor ended up with the same two tiers, whatever they call them. A raw event stream is lossless: the messages, the tool calls and the tool results, as they happened. An extracted memory is lossy and unanchored: a sentence a model wrote about what happened, stored without the thing it was written about. The first can be graded. The second is a claim, and a claim is what DIN grades, not what it grades against.
Inside the first column there is a second line that decides how strongly a record can be marked: are the tool results present verbatim? With them, a record is graded logged and its experiments count as direct output. Without them the best available honest mark is inferred, and DIN uses it rather than rounding up.
Live capture, as the work happens
Importing is for the history you already have. New work is captured live, on a paid plan, by the
plugin in this download: Claude Code through its plugin hooks, Cursor through Cursor's own
hooks.json, OpenCode through OpenCode's own plugin API, and Codex through the
capture sweep over its sessions. Nothing parses a tool's database and nothing automates its interface.
Each tool's captures are recorded as their own source.
Pick your agent. The installer asks which of those four to wire (or takes
--agent). Live capture is a paid feature, and so are several agents on one field at once;
history import stays free. Gemini CLI, Qwen, Cline and Grok history imports, and so does ChatGPT, from its
data export. claude.ai and the Claude desktop app's chats are import-only too, from the claude.ai data
export. Cloud chat apps have no local capture: their history comes in through import, and
hosted access is set up with you.
Recall into the agent reaches Claude Code (the plugin's prompt hook and /din), Cursor,
OpenCode, Codex and Gemini CLI once wired. Any other agent runtime asks the field over its HTTP API with
the field token, and every tool can use din recall in a terminal.
How DIN reads any of it
- A local file your own tool wrote. The CLI agents all keep one, and that is the good case: automatic, complete, already on your disk.
- A file you downloaded. Web chat is export-only. That needs one mapper per vendor, and each one waits on a real export to read rather than a guess at its shape.
- An API your own administrator authorised. The enterprise path: a tenant-wide pull, so nothing has to be installed on anybody's laptop.
DIN never automates a vendor's web interface. Every major provider forbids it, and an ingestion path that breaks somebody's terms of service is not one we will ship. Nothing on this page needs your password to a service that is not ours.
What is not here, and will not be
- Desktop apps have no readable local store. The ChatGPT, Claude and Gemini desktop apps, the
Windows Copilot app and the Grok app are web shells over the cloud: there is a cache, and a cache is
not a transcript. Use the vendor's CLI, or one of the three exports DIN reads: the ChatGPT data export (
din import --source chatgpt --export), the X (Twitter) archive for Grok (--source grok), and the claude.ai export, which also carries the Claude desktop app's chats (din import claude-ai). There is no Gemini, Copilot or Grok-app export mapper. Nothing is built on any of the apps. - A memory that mutates gets snapshotted. Where DIN does grade a claim that came from a vendor memory ID, it copies the content bytes at grading time, because several of those products re-extract, merge or auto-resolve their own memories. A grade that pointed at an ID whose text changed later would be a grade of something nobody said.
- Aggregation is not the product. Pulling several vendors' local sessions into one place is becoming a free platform feature, and DIN will happily be one more reader of those files. The grading is the part that is sold.