Suvadu vs Atuin: Shell History and AI Agent Workflows

Atuin and Suvadu both keep shell history in a local SQLite database with far more context than a history file, both record commands run by AI coding agents, and both ship an MCP server. Feature checklists therefore do not separate them well. This comparison instead walks through four jobs you might hire either tool for: recovering a command, importing existing history, inspecting what an agent did, and finding out why a command failed.

Review note: I build Suvadu. I reviewed this article on 19 September 2026 against Suvadu 0.4.1 (source and release notes) and the Atuin v18.22.0 release (published 9 September 2026), checking its MCP and agent-hook docs at that release tag alongside the current Atuin documentation linked below. This is a documentation and source review: I did not install and benchmark Atuin, so there are no comparative performance claims here.

The short decision

If you already use Atuin and mainly want recall, switching to Suvadu 0.4.1 has real costs: there is no Atuin or Bash importer, and typed search currently has a candidate limit described below. Suvadu's advantage is the agent-session workflow, so evaluate that first.

Suvadu vs Atuin at a glance

Task 1: recover a command you ran months ago

Atuin's interactive search is fuzzy by default and can switch between all history, one host, the current directory, the current Git workspace, or the current session. Its configuration also offers prefix, full-text, and daemon-backed fuzzy modes. Both Ctrl+R and Up-arrow open that interface by default; --disable-up-arrow keeps the shell's normal arrow behavior.

Suvadu's Ctrl+R search is intentionally literal: every typed word must appear as a substring. It ranks prefix matches above contiguous matches, followed by in-order and any-order word matches. A shorthand such as gco therefore does not match git checkout. Up-arrow stays in the prompt and cycles recent commands, preferring the current directory on ties.

Known limitation in Suvadu 0.4.1: when you type a query, interactive search only matches within the newest ~5,000 eligible entries. With a large history, an older command can be missing from the results even though it is still stored. Narrowing with a date or directory filter brings older entries into range. A fix is planned but not released yet. For the "find that command from months ago" job, this is a real point in Atuin's favor today.

Neither search model wins universally. If fuzzy recall and scope switching match how you search, Atuin fits. If predictable literal inclusion and conventional recent-first arrow recall are easier to reason about, Suvadu may suit you once the limit above is fixed or if your history is small.

Task 2: import the history you already have

Atuin's import reference documents atuin import auto, which detects your shell, and dedicated importers for Bash, Zsh, zsh-histdb, Fish, Nushell, xonsh, PowerShell, resh, and replxx.

Suvadu 0.4.1 imports exactly two formats:

suv import --from zsh-history ~/.zsh_history --dry-run   # preview
suv import --from zsh-history ~/.zsh_history
suv import backup.jsonl                                    # a Suvadu JSONL export

Migration limits to plan for:

• No Atuin importer. Suvadu cannot read Atuin's database. There is no published, tested conversion path yet, so do not count on moving Atuin history across.
• No Bash-history importer. ~/.bash_history is not a supported format, even though Suvadu records Bash going forward.
• Zsh imports carry what the file has. With EXTENDED_HISTORY you keep timestamps and durations; plain-format lines are stamped with the import time instead. Directory, exit code, and session were never in the file, so imported entries do not have them.
• New context starts at activation. Rich fields such as directory, exit status, and agent attribution exist only for commands recorded after the shell hook or agent integration is active.
• Nothing is changed at the source. Importing reads the file; your Zsh history file and any Atuin database stay as they are.

Running both tools side by side is not a tested setup yet. Both bind Ctrl+R and the arrow keys, so if you experiment, keep only one tool's bindings active.

Task 3: inspect what an agent session did

Atuin's current agent hooks (atuin hook install claude-code, codex, opencode, or pi) record each Bash-tool command an agent runs, with the agent as author, plus directory, timestamp, exit code, and duration. Interactive search hides these by default, and atuin search --author filters by agent. That answers "which commands did the agent run?" well. The reviewed docs do not describe capturing prompts or assistant responses.

Suvadu also records agent commands, but for Claude Code, Codex, and OpenCode it additionally captures the native session: your prompts, the assistant's responses, every observed model, and provider-reported token counts, including sessions that ran no commands. A typical 0.4.1 workflow:

# once per agent (rerun after upgrading, then fully relaunch the agent)
suv init claude-code        # or: suv init codex, suv init opencode

# after some agent work
suv sessions                # one picker for terminal and agent sessions; Ctrl+T cycles All/Human/AI
suv agent sessions          # the same AI sessions as JSON, for scripts
suv agent session <id>      # events, commands, tokens, and saved summaries as JSON

For Codex, also review and trust Suvadu's hooks with /hooks in the Codex CLI. A transcript that was not captured live can be added with suv agent import-session <path> (Codex or Claude Code JSONL).

To hand work from one agent to another, allow connected agents to save summary checkpoints. This write is off by default; add it to Suvadu's config.toml and restart the agent so its MCP server reloads:

[mcp]
allow_session_summaries = true

Then ask the agent to "summarize and save this session". It finds the session (resolve_current_agent_session), reads it (get_agent_session), and saves a summary with references to the captured evidence (save_session_summary). The agent writes the summary; Suvadu stores it. Another agent, or you in suv sessions (press s on an AI session), can read it later. Token figures are what each provider reports, not a normalized cost estimate.

Shared skills work alongside this. Keep a recurring checklist once and write it into each agent's own files:

suv skills add deploy-checklist --description "Steps before a deploy" < deploy.md
suv skills sync             # Claude Code skills, Cursor rules, Codex AGENTS.md

Atuin also has skills, used by its built-in Atuin AI assistant; Suvadu's difference is managing one set of instructions across external agents. Suvadu's Prompt Explorer and agent reports add prompt-to-command browsing and risk summaries.

Next step: the sessions guide covers capture coverage per agent, the session browser, and saving and reading summaries in detail.

Task 4: find out why a command failed

Both tools record the exit code, so both can list failed commands, including through MCP: Atuin's history tool has a failed-only filter, and Suvadu has what_failed, which groups recent failures by the prompt or session that triggered them, and learn_from_failures, which reports recurring failures in a project.

Seeing the actual error text is different. Atuin can capture command output when you enable its daemon and PTY proxy (off by default, kept locally with per-command and per-session limits), and its MCP output tool lets an agent read it. Suvadu 0.4.1 does not capture stdout or stderr, and its session capture excludes tool results. If agents diagnosing failures from real error output is central to your workflow, Atuin has the direct answer.

MCP: both expose history to agents

Atuin ships a read-only MCP server with two tools: history search, returning command, time, directory, exit code, and duration with scope, failure, and author filters; and captured output, which needs the output-capture setup above.

Suvadu's local MCP server exposes 21 read-only tools by default, covering command history, project context, recurring failures, risk assessment, skills, and agent sessions, plus resources and prompts. Two write paths, saving session summaries and proposing skills for human review, are off until you enable them. A larger tool count is not proof of better answers; compare the specific questions you want an agent to answer.

Local storage and sync

Both tools store history locally. Atuin's sync setup is optional and end-to-end encrypted; users can choose its hosted service, self-host, or stay local. If seamless history across several machines is the requirement, Atuin has the direct answer.

Suvadu has no sync service. It can export JSON, JSONL, or CSV and import JSONL; JSONL re-import skips duplicates by default. Moving and scheduling those files is your responsibility. In either tool, an MCP client that reads your history receives that data and may send it to its model provider under the client's settings.

Performance and maturity

Both command-line clients are written in Rust. This review did not run comparable benchmarks on the same hardware and history dataset, so it would be misleading to name a speed winner. Test startup, search responsiveness, and search completeness with your own history if they are deciding factors.

Atuin is much older and more widely used, with broader shell and platform support and more import paths. Suvadu is a young project with a narrower shell focus; its investment is in agent-session review, cross-agent checkpoints, and shared skills.

Should you switch?

Stay with or choose Atuin when shell recall is the main job, when you need its import coverage, wider shell and platform matrix, fuzzy scoped search, encrypted sync, or captured command output for agents. Try Suvadu when Bash or Zsh is enough and you want to inspect and continue agent sessions across Claude Code, Codex, and OpenCode, and the migration and search limits above are acceptable for you.

brew tap AppachiTech/suvadu && brew install suvadu

curl -fsSL https://downloads.appachi.tech/suvadu/install.sh | bash

cargo install suvadu

eval "$(suv init zsh)"

source ~/.zshrc

eval "$(suv init bash)"

source ~/.bashrc

suv doctor

If neither description settles it, keep your current history data intact and try Suvadu on one agent session first; the sessions guide shows what to check. For the broader field, see Atuin, fzf, McFly, hstr, and Suvadu compared.