Install DIN
The free build is one download: fifteen programs, the plugin and an installer. No account, no signup and no card. This page covers release 1.0.42.
Which platforms
- Linux x86-64: supported. This is the platform the release is built and checked on.
- macOS: available on request. It is not on the download page: write to support@dinctrl.com. The Linux installer says so on a Mac and stops, rather than failing halfway through a copy.
The one line
curl -fsSL https://dinctrl.com/install | sh
That is steps 1 to 3 below, done for you, and it checks before it runs anything:
1. It refuses anything but Linux x86-64 by name, and a Mac unless the release carries a macOS build (on a Mac: "DIN for macOS is available on request: this release has no macOS download"). 2. It reads SHA256SUMS from the download page's own directory. The archive's name, and so the version, comes from that list. 3. It checks SHA256SUMS.minisig against the key printed below, which is written into the script and never fetched: with minisign when it is installed, otherwise with OpenSSL 3 or later, which most Linux machines already have. With neither, it stops and installs nothing: it prints "SIGNATURE NOT CHECKED, so nothing was installed" and names the two ways out, install minisign or run it on a machine with OpenSSL 3 or later. 4. It downloads the archive and stops unless its SHA-256 matches SHA256SUMS. 5. It unpacks the archive into a temporary directory and runs its install.sh, at your terminal, so the agent question below is still asked.
Any mismatch: it deletes the temporary directory, installs nothing, and exits non-zero. It never uses sudo. You can read it first: open dinctrl.com/install in a browser.
Every installer option works from the one line, after sh -s --:
curl -fsSL https://dinctrl.com/install | sh -s -- --agent cursor
curl -fsSL https://dinctrl.com/install | sh -s -- --prefix /opt/din --no-start
curl -fsSL https://dinctrl.com/install | sh -s -- --path
--path is the one-liner's own option: it adds export PATH="<prefix>/bin:$PATH" to your shell's profile (~/.bashrc, ~/.zshrc or ~/.profile). Without it, nothing is edited and the line is printed for you to run.
Or do it by hand, reading the archive before you run anything:
1. Download
Everything is on the download page. These are the release files:
- din-1.0.42-linux-x86_64.tar.gz: the Linux x86-64 build
- SHA256SUMS: the SHA-256 of the release archive and producer-allow.txt
- SHA256SUMS.minisig: the minisign signature over SHA256SUMS
- minisign.pub: the public key SHA256SUMS is signed with
- producer-allow.txt: the sha256 of this release's din-record, din-session-record and din-import, the three producers a re-grade may come from (the copy the archive installs)
From a shell:
curl -fsSLO https://dinctrl.com/download/din-1.0.42-linux-x86_64.tar.gz
curl -fsSLO https://dinctrl.com/download/SHA256SUMS
curl -fsSLO https://dinctrl.com/download/SHA256SUMS.minisig
2. Verify the download
Every release is signed with minisign. The public key (key id 36C9AB1B4CC4A458) is printed here, not only shipped beside the download it vouches for:
RWRYpMRMG6vJNhzPUkYbbwTX9ebqgd1rW50Rlkv+/BZ4uAPzfda0KTqK
# install minisign first: apt install minisign / brew install minisign
minisign -Vm SHA256SUMS -P RWRYpMRMG6vJNhzPUkYbbwTX9ebqgd1rW50Rlkv+/BZ4uAPzfda0KTqK
# -> Signature and comment signature verified
# -> Trusted comment: DIN 1.0.42 <date> (it names the version you downloaded; check it does)
sha256sum --ignore-missing -c SHA256SUMS
# -> din-1.0.42-linux-x86_64.tar.gz: OK
If either check fails, stop: do not run the installer. The installer does not check the signature for you. It checks only that the nine core programs and din-grade are present before it writes anything.
3. Install on Linux
tar xzf din-1.0.42-linux-x86_64.tar.gz && cd din-1.0.42
sh install.sh
export PATH="$HOME/din/bin:$PATH"
din status
din status is the check that matters. It names every program, says whether the field is up, says whether your token opens it, and tells you what to type next.
Pick your agent
DIN is for any agent: any agent runtime can read the field through its HTTP API with the field token, and a person can stamp a record. The installer wires the agents it knows. Run at a terminal, it asks which agent DIN should capture: Claude Code, Cursor, OpenCode or Codex, one or several, Gemini CLI for recall only, or 6, none: import only (ChatGPT and others, which have no live capture). Or say it up front with --agent, once per agent; --agent none is import only. With no --agent and no terminal (a script, a pipe) it picks the agent a person would have been offered, the first one it finds here (Claude Code when claude is on PATH, else Cursor, else OpenCode), and says which and why in its closing lines. With none of them here it wires none.
- Live capture: Claude Code, Cursor, OpenCode and Codex. Live capture is a paid feature, and so are several agents on one field at once; history import is free, graded up to the Reader level in the fixed 40,000-character window.
- Recall: Claude Code, Cursor, OpenCode, Codex and Gemini CLI, once wired.
- Import-only: Gemini CLI, Qwen, Cline and Grok history, and Codex's past sessions, are read by
din import --source <name>.--agent geminiwires recall only and tells you that command. - Graphiti and Zep: read by
din-import-graphiti, from a Graphiti or Zep endpoint you run. - ChatGPT: import-only, from its data export. In ChatGPT: Settings, Data controls, Export data; download the zip from the email, then
din import --source chatgpt --export <the zip>.--agent chatgptinstalls DIN, wires nothing live, and tells you that command. Graded inferred, because the export carries no tool results to check, on whichever grading path you set up (below). - claude.ai and the Claude desktop app's chats: import-only, from the claude.ai data export. On claude.ai: Settings, Privacy, Export data (the desktop app's chats are the same account, so they are in it); then
din import claude-ai <the zip>. Each conversation is kept in~/.din/vault/claude-ai/(secrets scrubbed by default), and importing the same export again changes nothing. Records are placed ungraded, with no model call and no cost;--gradegrades them, on any plan, Free included, as inferred, on your own inference.
Pick several on the free build and each is still wired, but the field serves one AI agent: the newest, with the others set aside and kept in full. The installer says so in one line. din field activate <agent> switches which one is served; a paid plan keeps them all live together, with live capture.
To change your mind after the install, there is no need to run the installer again:
din agent list # which agents are wired, and which one your field serves
din agent add cursor # wire claude-code, cursor, opencode, codex or gemini
din agent remove cursor # unwire it; its records stay in your field
On the free build, din agent add first says what a second agent does and, at a terminal, asks before it wires anything (--yes to skip the question). With no terminal to ask at (a script, or the console's Settings page with its box unticked), it wires nothing unless you pass --yes.
The installer takes these options:
sh install.sh install into ~/din and bring it up
sh install.sh --agent cursor which agent to capture (repeat for several):
claude-code, cursor, opencode (live capture, paid);
codex (recall; live capture, paid);
gemini (recall; history by import);
chatgpt, qwen, cline, grok, zep, graphiti,
none (import only: nothing is wired)
sh install.sh --grade-with key how grading runs: cli, codex, key or local
(--grade-model M, --grade-url URL)
sh install.sh --prefix /opt/din somewhere else
sh install.sh --dry-run print every step, touch nothing
sh install.sh --no-plugin skip the plugin: no agent is wired
sh install.sh --no-start lay it down but do not start the field
sh install.sh --port 8093 the field's loopback port
sh install.sh --console-port 8097 the local console's loopback port
sh install.sh --schedule also schedule the capture sweep (cron)
More than one field
New in 1.0.32. One install can hold several fields, for example one per client or per project. Each has its own store, its own token (mode 600, never printed) and its own loopback port; they share this install's programs and your plan, and each starts on first use like your main one, which is called main.
din field new work # ~/din/fields/work, on a free port (or --port N)
din field list # every field: port, records, active agent, "N of M" on your plan
din field use work # the default for recall, query, brief, console and import
din recall --field work "<q>" # --field picks one field for status, console, import, recall,
# query, brief, where, dep-audit and din field start|stop|status
Your plan includes a number of fields, and din field list shows how many you have of that number. From 1.0.39 that number is enforced: past it, din field new (and din field routes --import-capture-map <file> --create, and the console's Fields control) makes nothing, says your plan, how many fields it includes and how to get more, and exits 3. Free includes 1 field, your own main, so on Free din field new refuses; on Free up to 3 people review that field. The fields you already have are never touched: an install with more than its plan includes (made before 1.0.39, or kept after a downgrade) keeps every field working, and din field list says OVER PLAN.
To have captures land in the right field, route each project to it. The plugin reads the routes at the end of each session and places that session's records into its project's field:
din field route my-repo work # sessions in that project go to `work`
din field route --default main # every project with no route of its own
din field routes # what is routed where
din field unroute my-repo
A project is matched, ignoring case, by the folder you work in (or DIN_CHANNEL), its name in DIN_PROJECT_MAP if you use one, or Claude Code's own name for the folder. With no routes at all, everything goes to your main field, as before. din status and /din status show each field and its last capture. If you kept a hand-written capture-map.json, din field routes --import-capture-map <file> shows what it would route, and --create also makes the fields it names. You can also make fields from the console: see Console settings.
Routes apply to everything that captures on this machine: the plugin's hooks and sweep, the Codex sweep, and din capture. If a route names a field whose store is not there, nothing is placed, in that field or any other. The log says why, and the run is placed on a later pass once the store is back.
A field can belong to another install on the same machine, for example a server with one install per field. Attach it by its store, then route to it. Its port and token file are recorded for din status and din field routes; the token file is never read, and nothing of that install is started or changed. An attached field counts as one of your plan's fields.
din field attach core2 --store /srv/core2/records --port 8301 --token-file /srv/core2/.din/field.token
din field route --default core2 # captures from this machine go to core2
din field detach core2 # after removing the routes to it; the store is untouched
On a server, a timer can feed one field with no capture map. Live capture needs a paid plan.
din capture --once --field=core2 --skip-headless # one pass
din capture install-task --field=core2 --skip-headless # every 10 minutes
--field <name> and --field=<name> are the same flag. A project with a route of its own still goes to its route. With no capture map, the pass reads every project your din capture exclude and din capture only settings allow, and din capture off stops it. It starts from now: sessions already on disk are left alone unless you add --backlog. --skip-headless leaves out claude -p and SDK sessions, and applies to din capture only: to keep such sessions out of the plugin's hooks and sweep, exclude their folders with din capture exclude <path>. An exclusion also covers folders whose name only begins the same way, so excluding /srv/work skips /srv/work-2 too. Run either this timer or the plugin's sweep on a machine, not both, or a session is captured twice.
--skip-headless leaves out claude -p and SDK sessions, and it is off by default. It is for a box where people work and spins run beside them. On a box where all the work is headless (supervisor mode), do not turn it on: it would leave out everything. Exclude only the directories you do not want captured, for example din capture exclude ~/agent-runs.
What the installer does
- On an upgrade, if the field from the same install is running, stops it with
din field stopfirst. If it does not stop, nothing is replaced. - Copies the fifteen programs into
~/din/bin(among themdin-session-record, the producerdin captureruns;din-grade, the graderdin-importhands every grading command to;din-import-graphiti,din-libcatalog,din-regrade,din-sourceanddin-refereeonly when the download carries them, as this release's archive does), and linksdin-recalltodin(the name the plugin's/din recalllooks for). - Puts
producer-allow.txtbeside the programs: the sha256 of the three producers a re-grade may come from,din-record,din-session-recordanddin-import.dinctrl-store ingest --regraderefuses a replacement from any other. - Copies
LICENSE,NOTICEandTHIRD-PARTY-LICENSESinto~/din/share/doc/din. - Creates
~/din/records(your records),~/din/.din(settings) and~/din/logs. - Mints a field token into
~/din/.din/field.token, mode 600. No DIN program ever prints it. An existing token is never overwritten. - Writes
~/din/.din/field.envwith the field on127.0.0.1:8093and the console on127.0.0.1:8097. An existing file is left alone. - Writes the plugin's settings to
~/.din/plugin.env, pointing it at this install. An existing file is left alone. - Starts the field on loopback with
din field startand waits for it. - Wires the plugin into the agent you picked: Claude Code through its plugin installer, Cursor through its
hooks.json, OpenCode through its plugin directory. With import only, nothing is wired and no sweep is scheduled.
How grading runs: your own inference
Nothing in the install needs an API key, and DIN never pays for, proxies or sees a model call. Three steps call a model, each on your own inference and each forecasting its cost first: din import --grade, din grade on (which grades live-captured sessions, so it needs live capture, a paid feature) and din regrade --run. None needs a spend cap; a cap you set (for example din grade on --daily-cap USD) holds, with one exception: on a model no price card covers, on a path that may bill per call (an OpenAI key, for one), a dollar cap cannot count, so it is not used and grading is held to 3 attempts a day instead. The installer asks how to grade (or say it with --grade-with cli|codex|key|local, and --grade-model M, --grade-url URL), and din setup model changes it later. There are three ways:
- Your assistant CLI, signed in: Claude Code (
claude) or Codex (codex, on your ChatGPT plan). Nothing is stored. Inside a subscription it uses your plan's limits. - Your own API key: Anthropic, OpenAI, or any OpenAI-compatible endpoint (
din setup model --key, with--base-url URLfor an endpoint). The key is stored on this machine in$DIN_HOME/model-keys.env, readable only by you, is never on a command line, and goes only to that vendor's host. - A local model: Ollama, vLLM or llama.cpp on this machine (
din setup model --local [URL] --model M). Nothing leaves the machine.
With more than one here, the order is the CLI (Claude Code first, then Codex), then a key, then a local model; din grade on --via cli|codex|key|local picks one. Claude Code is the path DIN's grading was measured on. The Codex, API-key and local-model paths are built and tested against stand-ins; none of them has been validated against a real vendor yet.
Where a grading call goes is set in ~/.din/plugin.env, not by your agent session's environment, because a repository's .claude/settings.json env block reaches the hooks: the proxy and CA settings (HTTP_PROXY, HTTPS_PROXY, ALL_PROXY, NO_PROXY, SSL_CERT_FILE, SSL_CERT_DIR, CURL_CA_BUNDLE, NODE_EXTRA_CA_CERTS), ANTHROPIC_BASE_URL, CLAUDE_CODE_USE_BEDROCK and CLAUDE_CODE_USE_VERTEX, CLAUDE_CONFIG_DIR, CODEX_HOME and XDG_CONFIG_HOME; so are where capture reads (DIN_TRANSCRIPTS) and your licence file (DIN_ENTITLEMENT). The plugin installer copies the proxy, the CA, CLAUDE_CONFIG_DIR, CODEX_HOME and XDG_CONFIG_HOME from the shell it runs in (only names plugin.env does not hold yet), and din setup model copies the proxy and CA. Otherwise put one there yourself, or put DIN_TRUST_ENV=1 in plugin.env to let the environment set them.
On Codex or an OpenAI key, a level depends on the model and its reasoning effort: din grade on --effort <level> sets it (every path runs at medium otherwise), and OpenAI levels above medium need it. gpt-6-sol at medium effort reads at Reader on any plan, Free included; Analyst and up are paid. DIN picks no model for you on Codex: name one. Grading on the Gemini CLI is turned off: DIN cannot run it with its tools locked down.
A paid install also checks in with our licensing service, with its random install id: when you run din activate, at most once a day when the field or the console starts, and daily from its timer once you turn on din autostart on. Each signed check-in lasts 14 days. A free install never checks in.
Next
- Activate a paid licence, if you have one. The free build needs no activation.
- Console settings: activate a key, webhooks, capture, agents and fields from the local console.
- Upgrade to a later release.
- Uninstall, and what happens to your records.
- Push your records to a hosted field, if you have a hosted plan.
- The command-line reference.