Waku combines coding-agent CLIs in a native local desktop app

Why it matters

Coding agents are multiplying faster than their interfaces. Waku is betting the durable layer will be a local, provider-neutral record of agent work and code state.

Waku current version 0.1.0 is a native desktop control plane for the coding-agent command-line tools developers already run. Built in Rust with GPUI, Waku collects sessions, transcripts, tool activity and repository checkpoints inside one local application.

The builder has made a focused product bet. Developers who use several coding agents do not necessarily need another agent, model or editor. They need a reliable place to see what each agent did, interrupt it, continue the conversation and recover when a task goes wrong.

That decision shapes nearly every part of Waku. It avoids Electron, stores its working data on the user's machine and connects to existing agent CLIs through their structured interfaces. The application then translates those different event streams into one provider-neutral model.

One interface above the agents

Waku is designed to drive existing tools rather than ask developers to adopt a new agent runtime. According to its product page, the application connects through interfaces including stream-JSON, JSON-RPC and live events, choosing the strongest available connection for each provider.

The screenshot published by Waku appears to show Amp, Claude Code, Codex, Cursor, OpenCode, Grok and Pi in the underlying driver layer. The architectural goal is to make those providers appear as sessions on a common timeline while preserving their own authentication and execution paths.

That approach gives the developer behind Waku a different job from building a model wrapper. Each supported CLI can change its event schema, session format and resume behavior independently. Waku's value will depend on how well its adapters absorb those differences and how quickly they recover when providers update their tools.

The interface is keyboard-first. Waku says Command-N starts a session, Return queues another prompt while an agent is working, Command-Return steers the active turn and Escape stops it. These controls treat agent work as an ongoing process that needs supervision, rather than a sequence of isolated chat messages.

Rollback is the core product decision

Waku's most consequential feature sits below the transcript. Every prompt creates a checkpoint of the working tree under a hidden Git reference. A developer can then restore the repository and the associated provider conversation together.

That pairing matters because a chat log alone is an incomplete record of an agent's work. Coding agents read files, run commands and edit a repository over multiple turns. Reopening an old message without restoring the corresponding code leaves the conversation and working tree out of sync.

Waku's builder is effectively treating the prompt as a transaction boundary. Each instruction links a conversational state to a repository state. That creates a path back when an agent follows the wrong approach, makes an overly broad change or leaves the project in a state that is difficult to diagnose.

The mechanism also gives Waku a clearer role than a general-purpose agent dashboard. It becomes a local record of what the developer asked, what the agent reported and what changed in the code at that point.

Native software is part of the bet

The choice of Rust and GPUI is central to Waku's pitch. GPUI is the GPU-accelerated interface framework created by the team behind Zed.

Waku's homepage says the native application avoids Electron and offers instant startup and smooth navigation through long transcripts, though it does not publish independent performance measurements.

Waku also says projects, transcripts, sessions and provider identifiers remain on disk, with no Waku account, telemetry or hosted intermediary. That local architecture reduces the amount of infrastructure Waku must operate and gives developers direct custody of the application's records.

It does not make the underlying coding agents local. Prompts, code and tool output remain subject to the behavior and policies of whichever agent CLI and model provider the user selects. Waku controls its own storage layer; it does not replace the providers beneath it.

For distribution, Waku says the application is signed and notarized, with Sparkle handling automatic updates through binary deltas. That detail matters for a young desktop product whose integrations may need frequent repairs as agent vendors change their interfaces.

Coding-agent control planes are getting crowded

Waku arrives as the interface around coding agents becomes a product category of its own. OpenAI introduced the Codex desktop app for macOS on February 2nd and added Windows support on March 4th. Codex organizes multiple agents into project threads and isolated worktrees, but remains centered on OpenAI's agent stack.

Zed's agent system supports its native agent, external agents connected through the Agent Client Protocol and terminal-based CLI sessions. It also lets developers run multiple threads in parallel inside the editor.

cmux, a native macOS terminal for supervising coding agents, takes another adjacent approach with vertical tabs, notifications and a socket control API.

Waku chooses a narrower independent role. It is neither a full editor nor a first-party model interface. The developer is betting that programmers will keep several agent subscriptions and CLIs, creating demand for a neutral desktop layer above them.

Version 0.1.0 has to prove that neutrality under real provider churn. A unified timeline is useful only when sessions resume correctly, tool events retain their meaning and checkpoints restore the exact state a developer expects. Those reliability details will determine whether Waku becomes daily infrastructure or another interface developers open only to inspect an interesting demo.

The homepage's line, "YNot backed by Y Combinator," is wordplay rather than a financing announcement. Waku's current case rests on the product itself: a builder's attempt to turn a growing pile of agent terminals into one fast, reversible workflow.