Wake: A Local Index for Eighteen Kinds of Coding-Agent History
All your AI agent sessions in one place — browse, search, resume. Rust + GPUI.
At a glance
- What is it?
- Wake is a Rust and GPUI desktop app that reads the session files left behind by Claude Code, Codex, OpenCode and others, indexes them in SQLite FTS5, and lets you resume any conversation in its original terminal. It is macOS-first, read-only on your agent directories, and it deliberately skips agents whose local data is encrypted or cloud-only.
- Who is it for?
- Adopt Wake if you run several coding agents on macOS and want their local transcripts searchable in one window without uploading anything. Do not adopt it if your history lives in Cursor IDE chats, Windsurf, Trae, Amp, Factory or Warp, because those either encrypt local data or keep sessions in the cloud, and Wake does not read them.
- Can I use it commercially?
- Yes. MIT is a permissive licence: you can use, modify and sell software built on it, as long as you keep its copyright and licence notices.
- Is it still maintained?
- Yes. The repository last received commits 1 day ago.
- What is it written in?
- Mainly Rust, according to GitHub's language statistics.
Answers come from the project's GitHub data, last synced on September 15, 2026, and from our analysis. They are not legal advice.
DEEP OPEN-SOURCE ANALYSIS
The Scattered History Problem Wake Targets
Every coding agent keeps its own diary in its own directory. Claude Code writes JSONL under `~/.claude/projects`, Codex CLI keeps `~/.codex/sessions` plus a `state_5.sqlite`, OpenCode uses `~/.local/share/opencode/opencode.db`, and the README's table lists more than a dozen others, from Qoder and Kiro to Hermes Agent and OpenClaw. None of them know about each other. If you switched agents last month, the reasoning you want is in a file format you have to reverse-engineer before you can grep it.
Wake's answer is a single native window that reads all of those directories and presents them as one library. The README frames the situation plainly: your agent history is scattered across `~/.claude`, `~/.codex` and other private directories, and Wake reads them all, read-only. The audience is therefore narrow but real: developers who already run two or more agents locally and who care about finding an old decision rather than starting a fresh conversation. Anyone who uses exactly one agent and never revisits past sessions gets little from it.
Read-Only Ingestion, SQLite FTS5, and a Watcher on the Side
The architecture visible in the README is an indexing layer rather than an agent runtime. Wake does not proxy model calls or wrap the CLIs. It parses each agent's on-disk format into a common session model, groups sessions by agent and project, and stores its own metadata (stars, pins, tombstones for deleted sessions) in a separate database. The original files are never modified, which is why starring a session does not touch `~/.claude`.
Search is the load-bearing component. Wake builds a SQLite FTS5 trigram index, which the README claims handles CJK text and code substrings such as `useEffect(` equally well. That claim matters because trigram indexes trade index size for substring matching; without a trigram tokenizer, searching for a mid-identifier fragment like `useEffect(` would usually fail. Selecting a result jumps to the matched message inside the transcript view rather than merely opening the session.
The transcript renderer is more than a text dump: per-message user and assistant bubbles, inline images that can be copied or saved, collapsible tool-call clusters, thinking summaries, and tree-sitter highlighting across 30 or more languages. Live file watching updates the list incrementally as agents write new turns. Grok Build subagents are nested under their parent session, which suggests the parser understands at least one agent's parent-child session structure rather than treating every file as a flat conversation.
Getting It Running and Pointing It at Remote Machines
The README documents installation through GitHub Releases rather than a package manager; the platform badge reads macOS 14+, with Linux and Windows marked beta since v0.2.5 and v0.2.7 respectively. There is no Homebrew or cargo install line in the supplied material, so treat the releases page as the distribution channel.
Most configuration lives in the app. Settings → Remote hosts is where you add another machine, either as an alias from `~/.ssh/config` or as `user@host`. Wake then asks the remote which known agent directories exist, mirrors only those with `rsync` into `remotes/<host>/` under its own data directory, and syncs on launch, on refresh, or when you click Sync now. Remote sessions get an `@host` badge and resume through a copied `ssh -t` command in the shape `ssh -t <host> 'cd <project> && codex resume <id>'`.
Two prerequisites are stated explicitly and both are easy to trip over. SSH must work without prompts, because Wake runs without a terminal and can never answer a passphrase prompt, so your key has to be loaded into an agent and the host key trusted from a prior terminal connection. `rsync` must exist on both ends; Windows users install it themselves. Settings → Connect is the other configuration surface, holding copy-paste snippets for wiring the bundled `wake-mcp` server into Claude Code, Codex, Cursor or another MCP client.
Where Wake Stops: Encryption, the Cloud, and Remote Assumptions
The supported-agents table is as notable for its exclusions as its inclusions. Cursor IDE chats, Windsurf and Trae encrypt their local data, and Amp, Factory (Droid) and Warp keep sessions in the cloud, so none are supported. Antigravity CLI appears in the table but only as metadata, because its transcripts are encrypted. Reasonix stores sessions locally but has not been mapped. If your workflow runs through Cursor's IDE chat panel rather than its CLI transcripts, Wake will show you nothing for those conversations, and no amount of configuration changes that.
The remote feature carries its own boundaries. Remote sessions are read-only in Wake: they cannot be moved to the Trash, and the mirror follows whatever is on the remote. Wake assumes each remote agent uses its default paths under the login user's home, so `CODEX_HOME`-style overrides on the remote are not detected, and remote Windows machines are not supported at all. Only session data and sidecar files are copied, never credentials, and nothing on the remote is written.
Coverage is also uneven by design. The table's Model column shows a checkmark for Claude Code, Codex, Qoder, OpenCode, Kiro, Pi, Oh My Pi, Grok Build, DeepSeek Harness, Hermes and OpenClaw, but not for Copilot CLI, Cursor CLI transcripts, Gemini CLI, Kimi Code or Antigravity. The README is explicit that a dash means the agent's local data does not record that field, not that Wake failed to implement it. That is a fair distinction, and it also means you cannot expect uniform metadata across the library.
How Wake Differs from an Agent's Own Resume Command
The obvious alternative is doing nothing: each CLI already has a resume path, and the README's own resume implementation shells out to `claude --resume` or `codex resume` in the original project directory. If you only ever resume the session you just left, `claude --resume` in that directory is one keystroke and needs no second application.
The difference is the search surface. The native resume command knows about its own agent's history and nothing else; it cannot find a Codex session by a phrase you remember writing in Claude Code. Wake's trigram index spans every supported agent, and the MCP server extends that span to machines that are not you: `wake-mcp` is described as a bundled read-only server that lets an MCP client search your whole history, list recent sessions per project, and read transcripts page by page, so a new agent can pick up where another left off. That is a different job from resuming, and it is the part no single CLI provides.
The cost of the wider surface is a second process to keep current. Wake's parsers track other projects' private file formats, and those formats change without notice. The release cadence visible in the material, v0.5.0 and v0.5.1 on consecutive days in September 2026 followed by v0.5.2 the next day, suggests active format-chasing rather than a frozen reader.
Maintenance Cost and the MIT Licence
Wake is MIT licensed, which permits commercial and private use, modification and redistribution provided the copyright notice and permission notice are retained. That is permissive and carries no copyleft obligation on your own code. It says nothing about the licences of the agents whose files Wake reads, and nothing here is legal advice; if you plan to redistribute a modified Wake, keep the `LICENSE` file intact and read it yourself.
The practical maintenance cost sits in two places. First, agent-format drift: every supported agent can change its JSONL schema, its SQLite layout or its directory naming, and Wake has to follow. Second, the remote path: `rsync` availability, non-interactive SSH, and the assumption of default home-directory paths mean a working setup can break for reasons that have nothing to do with Wake. Updating is a matter of pulling a newer release from GitHub; the README states that Wake contacts GitHub only when you explicitly check for an update, so there is no background phone-home to reason about.
Editorial conclusion
Adopt Wake if you run several coding agents on macOS and want their local transcripts searchable in one window without uploading anything. Do not adopt it if your history lives in Cursor IDE chats, Windsurf, Trae, Amp, Factory or Warp, because those either encrypt local data or keep sessions in the cloud, and Wake does not read them. Before committing, confirm two things on your own machine: that your agent versions write the paths listed in the supported-agents table, and that `claude --resume` or `codex resume` actually works in your terminal host, since resume depends on those CLIs rather than on Wake.
Community notes