Atuin Threads in Atuin 18.24: Synced, Searchable Agent Sessions Across Every Machine
Atuin 18.24 introduces Threads, a feature that syncs AI coding agent sessions across machines so a task started in Claude Code on a dev server can be resumed — or forked into a different agent harness like Codex — on a laptop, with full context intact. It matters because agent sessions now hold the reasoning, intent, and failed attempts behind work that never reaches Git or an issue tracker, and that record has until now been stranded on individual machines.
What Atuin Threads does
Atuin Threads gives you one searchable, synced history of every agent session on every machine. The entry point is a single command: atuin resume.
Start a task in Claude Code, then resume it in Codex on another machine with all context intact. The feature is available starting with Atuin 18.24.
Supported agent harnesses at launch:
- Claude Code
- Codex
- Pi
- Omp
- OpenCode
Atuin says more agents are coming soon.
Why agent sessions are the new shell history
Agent sessions are a richer record than shell history because they capture intent, not just commands. Shell history records what ran; it never kept the reasoning or the intentions behind a command. An agent session stores every command, its output, the original prompt, and everything tried along the way to a solution — in plain English, already sitting in your home directory.
Atuin's author frames this as the same problem that motivated Atuin originally: work history was ephemeral, with every typed command destined to vanish on line 501 of .bash_history. Indexing that history made it recallable in seconds. Threads applies the same idea to agent sessions, which are currently scattered across laptops, dev servers, ephemeral instances, and bare-metal boxes, and are difficult to search once you have moved on.
How the sync works
Threads is built on Atuin's existing encrypted sync engine, which is generic and can sync anything modelled as an append-only log. Most AI sessions are exactly that.
Key properties:
- End-to-end encryption. Sessions are encrypted when synced, so the Atuin operators cannot read them.
- Hosted, self-hosted, or local. You can use Atuin's hosted sync server, run your own server, or keep everything local.
- Opt-in capture. Capturing agent sessions is disabled unless you enable it.
MCP: letting agents search their own past
Atuin exposes prior sessions to agents through an MCP server, available as atuin mcp. It can be installed automatically for a supported harness with:
atuin mcp install claude/codex/pi/opencode
With MCP, an agent can search and reference previous sessions itself — finding work done before, understanding why a decision was made, and building on earlier investigations without re-deriving context.
Three concrete use cases from the announcement
Recovering abandoned work
Repeated attempts at an onboarding and setup flow never quite landed, but the sessions recording those attempts persisted. When an agent is asked to work on onboarding, it can find previous attempts along with why they were abandoned and what could be done better. Those sessions contain code that never reached main, plus the original prompts and iterations — enough for a later agent to infer intent without a written spec.
Tracing an object store outage
After a precautionary key rotation, one new object store key lacked permissions for avatar uploads, and the failure was not noticed immediately. A daily Sentry triage agent traced the failure to a command run earlier that day. Prompting a second agent with a short hint — "seeing some tigris avatar issues?" — led it to discover the earlier investigation, surface the cause, and develop a fix far faster than starting from scratch.
Forking a session across machines
During testing, one machine performed poorly. The investigating agent proposed poor I/O performance as the cause but needed a faster disk to confirm it. The session was forked onto a MacBook and continued from exactly where it left off; the faster SSD showed slow disk was only part of the story and that imports could be sped up elsewhere. The thread on the original machine then pulled the benchmark results back from the Mac and built the fix — no copy-pasting or manual coordination, and the results became part of the permanent record.
Team sharing is planned, not shipped
Atuin is building opt-in session sharing for teams, framed as handing off an agent thread like a Git branch. Much of the context behind engineering work never makes it into Git, issue trackers, or documentation, and it currently ends up scattered across individual agent sessions. Team sharing is described as in-progress, with an invitation to contact the team if it sounds useful.
Getting started
- Install or update Atuin:
curl --proto '=https' --tlsv1.2 -LsSf https://setup.atuin.sh | sh
- Run
atuin resumeto get started. - Install the MCP server with
atuin mcp install.
What the Hacker News discussion adds
The dominant theme in the comments is that this is a problem many engineers have already solved privately. As one commenter put it:
I suspect this is one of those problems "everyone" has built their own solution for. Including me!
Several commenters linked their own implementations, which is itself evidence of demand:
- slivingdoc takes a different approach: rather than syncing exact sessions, which the author calls "often quite noisy, and not so useful," agents summarize their context into living UTF-8 documents with automatic merge-conflict resolution backed by S3. Only a stdio MCP server needs to be added to each harness.
- ctools is deliberately Unix-flavored, with commands like
ctools resume ssh://laptop.local/code/projectthat find the most recent session for a path on a remote host, copy it locally, and resume it. It also offersls,grep,cat, andcopy. - pi-tools implements a "memory everywhere" module that turns all sessions into BM25 vectors and exposes memory tools so agents can search them, with a hub-and-spoke model for adding machines.
- Superlogical Rex and codealong are other attempts at the same problem, the latter with a desktop flavor.
- One commenter built a local-only version that scans session logs from all harnesses and adds embeddings for hybrid BM25/semantic search, calling it one of the few genuinely good uses of "using AI to work on my AI tools."
Counterpoints and open concerns
Token cost. One commenter asked whether replaying past entries to reconstruct context across machines and models would hammer token usage. This is a real design tension: the value of resuming with full context depends on how much of that context is fed back into the model.
Noise versus signal. A commenter building a similar tool noted uncertainty about where to hook in — events, harness hooks, terminal output, or Git hooks — and whether every session from every machine should be saved at all, given that many coding sessions are experimental or throwaway. The counterargument in the same comment: it is not that much data, and it is easy to ripgrep or feed to an LLM.
Sync granularity. One request was to disable sync for Threads while keeping shell history sync running — the two data types have different sensitivity profiles.
Retention. A commenter asked whether agent sessions are deleted after some time and expressed a preference for keeping them.
Reliability track record. One long-time user reported that Atuin lacked correct handling for EFSRO (read-only file system) errors, so a RAID drive failure on the /home mount broke their local shell, with the issue open for almost a year. This is a reminder that a tool sitting in the shell startup path carries availability risk.
Privacy of a shared server. A user who likes Atuin nonetheless voiced reservations about a shared server holding all shell history and agent sessions, and asked whether the concern was excessive paranoia.
Competition. One commenter argued that herdr has "really eaten this segment," particularly with its Mac app, and said vanilla terminal use now feels worse by comparison. Another summarized the broader trend bluntly:
So now everyone and their mother are putting out AI harnesses/session managers aka browser tabs for AI.
And on the proliferation of homegrown clones:
I love this new AI era of coding where the HN submission is about a new way to manage agent, and almost literally all the comments are "I just finished implementing this myself" It's almost like a parody.
The bottom line
Atuin Threads extends the original Atuin premise — that the history of your work should be useful, accessible, and yours to keep — from shell commands to agent sessions. The differentiators versus the many homegrown alternatives are cross-machine encrypted sync, harness-agnostic resume and fork, and an MCP interface that lets agents query past sessions directly. The open questions are token cost when replaying context, how much session noise is worth retaining, and whether users trust a synced server with the combined record of their shell and agent activity.
Atuin's own position is that shell history is not going away and is arguably more useful than ever; Threads is an addition to it, not a replacement.