FieldDIN your field. part of the DIN family.
Get DIN ☰Menu
Compatibility

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.

sourcelive capturehistory importfree placement (no model call)recall into the agentgrading backendspend capenterprise fleet
Claude Codeyes, on a paid plan: the DIN plugin's hooks, and the sweep over its transcriptsyes: din import --source claude-codeyes: captured sessions are placed observed-onlyyes: the plugin's prompt hook and /dinyour 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 vendoronly 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 modelyes: Claude Code managed settings
claude.ai and Claude desktop chatsno: a data exportyes: din import claude-ai <the zip>yes: placed ungradedno: din recall in a terminalyour 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 --gradeonly one you set: din import --max-spend; none on --via; nothing is billed per call on Codex or a local modelno
Cursoryes, on a paid plan: Cursor's own hooks.jsonnoyes: captured sessions are placed observed-onlyyes: DIN's recall hook, once wiredyour 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 vendoronly one you set: din grade on --daily-cap; nothing is billed per call on Codex or a local modelno
OpenCodeyes, on a paid plan: OpenCode's plugin APInoyes: captured sessions are placed observed-onlyyes: DIN's recall plugin, once wiredyour 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 vendoronly one you set: din grade on --daily-cap; nothing is billed per call on Codex or a local modelno
Codex CLIyes, on a paid plan: the capture sweep over its sessionsyes: din import --source codexyes: din import --ungraded places it with no model callyes: its hook and AGENTS.md, once wiredyour 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 vendoronly one you set: din import --max-spend; none on --via; nothing is billed per call on Codex or a local modelno
Gemini CLInoyes: din import --source gemini-cliyes: din import --ungraded places it with no model callyes: its hook and GEMINI.md, once wiredyour 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 vendoronly one you set: din import --max-spend; none on --via; nothing is billed per call on Codex or a local modelno
Qwen Codenoyes: din import --source qwenyes: din import --ungraded places it with no model callno: din recall in a terminalyour 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 vendoronly one you set: din import --max-spend; none on --via; nothing is billed per call on Codex or a local modelno
Cline, Kilo and Roonoyes: din import --source cline (or kilo, roo)yes: din import --ungraded places it with no model callno: din recall in a terminalyour 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 vendoronly one you set: din import --max-spend; none on --via; nothing is billed per call on Codex or a local modelno
claude-memnoyes: din import --source claude-memyes: din import --ungraded places it with no model callno: din recall in a terminalyour 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 vendoronly one you set: din import --max-spend; none on --via; nothing is billed per call on Codex or a local modelno
ChatGPT conversationsno: a data exportyes: din import --source chatgpt --export <the zip>yes: din import --ungraded places it with no model callno: din recall in a terminalyour 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 vendoronly one you set: din import --max-spend; none on --via; nothing is billed per call on Codex or a local modelno
Grok (X data archive)no: a data exportyes: din import --source grok --export <the zip>yes: din import --ungraded places it with no model callno: din recall in a terminalyour 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 vendoronly one you set: din import --max-spend; none on --via; nothing is billed per call on Codex or a local modelno
Zep and Graphitinoyes: din-import-graphitiyes: no model callno: din recall in a terminalnone: records keep the regime their source showsnot needed: no model callno
Any MCP client (the hosted DIN connector)receipts the agent files itself, on hosted DIN (set up with you)noyes: a receipt is graded by its evidence, no model callon hosted DIN, when you grant it (set up with you)none: no model callnot needed: no model callno
GitHub Copilotnono: no mappernono: din recall in a terminalnone: nothing is importednot needed: nothing is readno
Windsurfnono: no mappernono: din recall in a terminalnone: nothing is importednot needed: nothing is readno
Any other agent runtimenono: no mappernoyes: it reads the field over its HTTP API with the field token, and a person can stamp a recordnone: DIN grades only what it imports or capturesnot needed: no model callno

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.

Ten sources import today: Claude Code, Codex, Gemini CLI, Qwen Code, the Cline family (Cline, Kilo, Roo), claude-mem, Grok, ChatGPT (its data export), claude.ai with the Claude desktop chats (its data export), and Zep / Graphiti (through 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.
One active agent on Free. The free field serves one AI agent at a time: wire several and the newest is served, the others set aside and kept in full (din field activate <agent> switches which). Several agents on one field at once is a paid feature.
IMPORTS TODAY the importer ships and reads it today; grading it needs a model (the table above) PLANNED format read, mapper not written NOT EVIDENCE cannot carry a grade at all
Import, then grade

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.

20 sources. 10 import today.
Claude Code transcriptsIMPORTS TODAY
~/.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.
CodexIMPORTS TODAY
The rollout files under ~/.codex/sessions: full tool input and output, plus the session's own working directory and git state. din import --source codex.
Gemini CLIIMPORTS TODAY
The chat session files under ~/.gemini/tmp. Tool results are untruncated, which makes it the cleanest non-Claude source. din import --source gemini-cli.
Qwen CodeIMPORTS TODAY
The chat files under ~/.qwen/projects. din import --source qwen.
Cline family: Cline, Kilo, RooIMPORTS TODAY
The extension's own task history, in Anthropic-shaped JSON. din import --source cline (or kilo, or roo).
claude-memIMPORTS TODAY
Its anchor chain back to the session is present, so a memory it wrote still resolves to the turn that produced it. din import --source claude-mem.
GrokIMPORTS TODAY
The Grok chats inside an X (Twitter) data archive you downloaded. A web chat is not a capture of tool calls, and its records are marked for what a chat can show. din import --source grok --export <the zip>.
ChatGPT conversationsIMPORTS TODAY
The data-export zip (Settings, Data controls, Export data). Each conversation is read along the branch you last saw, not the edits and regenerations you moved away from. The export carries no tool results that can be checked, so its records are graded inferred. din import --source chatgpt --export <the zip>.
claude.ai and Claude desktop chatsIMPORTS TODAY
The claude.ai data export (Settings, Privacy, Export data). The Claude desktop app's chats are the same account, so they are in it. Each conversation is kept in your vault, secrets scrubbed, and importing the same export again changes nothing. Records are placed ungraded, with no model call; --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>.
Zep and GraphitiIMPORTS TODAY
Episodes, and edges that already name the episodes they came from. din-import-graphiti reads a Graphiti server you run, or Zep's, makes no model call, and ships in the download.
LettaPLANNED
Messages, kept whole.
LangGraphPLANNED
Checkpoints, out of whichever checkpointer the graph was run with.
OpenAI SessionsPLANNED
The session items as the API stored them, tool calls included.
AWS AgentCore eventsPLANNED
The raw event stream. Not the memory records AgentCore extracts from it, which are in the next column.
Azure AI Foundry conversationsPLANNED
The threads themselves, in your own Cosmos account, which is where Foundry puts them when you bring the store.
Google Agent EnginePLANNED
The session event stream.
SupermemoryPLANNED
Document level: the source document is kept, so a claim resolves to it rather than to a restatement.
KhojPLANNED
The indexed source, which is still a file on your disk.
Basic MemoryPLANNED
Markdown with byte offsets, so a claim resolves to a span of a file. It is also a write target.
SpecStoryPLANNED
Its saved session history.
Cannot grade

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.

9 products, one finding.
Mem0 hostedNOT EVIDENCE
Extracted facts. The turn they came from is not stored beside them.
Vertex AI Memory BankNOT EVIDENCE
Consolidated memories, with no pointer back to the conversation.
Azure AI Foundry MemoryNOT EVIDENCE
Memory items, merged by a model as they are updated.
AWS memory recordsNOT EVIDENCE
Extracted records, re-extracted on a schedule, so the text can change underneath.
ChatGPT memoryNOT EVIDENCE
A list of remembered facts, and a separate export from the conversations.
Claude.ai memoryNOT EVIDENCE
The same shape, and also a separate export from the conversations.
LangMemNOT EVIDENCE
Extracted profiles and facts.
The MCP memory serverNOT EVIDENCE
Entities and relations in a JSON file, none of them naming a message.
projectmemNOT EVIDENCE
Extracted project facts.
Write DIN records into

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.

3 targets, none of them live today.
GraphifyPLANNED
The code axis: file and line anchors, so a graded record lands on the code it is about.
Basic MemoryPLANNED
Byte offsets in markdown, which is a real anchor and not a note about one.
The Anthropic memory toolPLANNED
DIN becomes the handler behind it, so what an agent remembers is graded on the way in rather than audited afterwards.

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.
This page is about formats, not about a purchase, and it is the same on every build. If a source you need is on it as PLANNED, that is what it is: a schema that has been read and a mapper that has not been written. Ask, and it moves up the list.