Waveloom: An Open-Source Terminal AI Coding Agent Deeply Optimized for DeepSeek

An Open-Source Terminal Coding Agent Taking Aim at Claude Code

In a world overflowing with AI coding assistants, an open-source tool called Waveloom has been turning heads. According to its author's introduction on Bilibili, Waveloom is a coding Agent that runs in the terminal — capable of helping developers write code, manage files, and even handle some text-based creative tasks.

A "coding Agent" is fundamentally different from a traditional code completion plugin: it can plan across multiple steps, call tools, read and write files, and execute commands — completing programming tasks end-to-end rather than simply autocompleting a few lines at the cursor. The defining example of this paradigm is Anthropic's Claude Code — an autonomous coding assistant that runs in the terminal, and a landmark in the shift from AI-assisted to AI-autonomous programming.

Wavebloom's positioning is crystal clear: a replacement for Claude Code or Reasoning X. Reasoning X is a code agent specifically tailored for DeepSeek, and Waveloom targets the exact same niche — a coding agent deeply customized for DeepSeek. This model-specific deep optimization delivers one critical technical advantage: an exceptionally high cache hit rate.

Cache Hit Rate: The Core Cost Advantage

Why does cache hit rate matter so much? The author presents a compelling set of numbers: with the DeepSeek Pro model, the cost difference between a cache hit and a cache miss is up to 120x. That means a code agent with a near-perfect cache hit rate can deliver massive savings on token costs.

This ties into the KV Cache (Key-Value Cache) mechanism in large language models. When processing a request, the model caches the attention key-value pairs for tokens it has already computed. The next time it encounters the same prefix, it can reuse those cached results instead of rerunning expensive matrix operations. DeepSeek's pricing strategy slashes the per-token cost for cache hits to 1/120th of a cache miss — essentially converting compute cost into storage cost. For code agents that frequently carry large contexts (like system prompts and project files), this discount is enormous. Waveloom maximizes this mechanism by deeply customizing its prompt structure for DeepSeek.

The author mentions having used Waveloom to write code for about two weeks. Based on the token usage data he shared, total costs have been remarkably low, with cache hit rates consistently high — peaking at nearly 99%, leaving almost no room for further optimization.

For developers who make heavy use of LLMs on a daily basis, this cache efficiency translates to real, measurable cost savings. It's also Waveloom's key differentiator over general-purpose coding assistants: by deeply optimizing for a single model, it achieves extreme cost efficiency.

Cross-Platform Support and Getting Started

Wavebloom is currently at Alpha 13, supporting Linux, Windows, and macOS — covering the major development environments. Users can find the appropriate download instructions for their platform on the project's homepage and install via the command line.

First-time use requires a one-time setup to configure the theme, language, and most importantly the DeepSeek API Key. Once configured, navigate to your project directory and run waveloom to launch the interface.

The interaction model closely mirrors Claude Code: the input field supports slash commands, you can inject files via @, and pressing Shift + Tab enters Plan Mode — a read-only mode where the Agent won't modify anything. You can discuss and plan an implementation with it first, then exit the mode to execute actual changes. This two-phase "plan first, execute later" workflow significantly reduces the risk of Agent mistakes and aligns well with engineers' intuitive need for control.

Why Terminal Instead of a Desktop GUI?

The interface consists of three sections: a top bar showing model and workspace info, a main interaction area, and a status bar at the bottom displaying real-time cache hit rate, context window usage, and token consumption for the current session.

Wavebloom is a classic TUI (Text User Interface) application. Unlike a graphical GUI, TUIs use terminal control characters (such as ANSI escape sequences) to handle layout rendering and keyboard interaction. Common frameworks include Python's Textual and Rust's Ratatui. TUI apps don't require the OS's graphics subsystem, can run directly over SSH on remote servers, and have minimal memory footprints — which is why they've remained popular in server development and DevOps contexts.

The author explains his deliberate choice to build a terminal app rather than a desktop GUI. His core argument: programmers spend most of their time in the terminal. Outside of their editor, it's likely the most-used piece of software they have. Terminal apps offer several natural advantages:

• Lightweight — potentially only tens of megabytes to run;
• Low environment requirements — no graphics stack needed, works anywhere there's a terminal (including remote servers);
• Desktop apps, by contrast, are heavier, come with large installers, and require a graphical environment.

The author also admits he briefly tried Reasoning X but was put off by its interface — the biggest complaint being severe flickering during terminal output, which was visually uncomfortable. Terminal flickering typically comes from a "full-screen redraw" strategy: clearing and re-rendering the entire terminal on every update instead of only refreshing changed regions (incremental rendering). Waveloom, by contrast, uses a statically fixed layout — header, body, and footer each in their place — with incremental updates applied per region, resulting in a much more stable visual experience. For programmers staring at a terminal eight to ten hours a day, this kind of polish is something the author considers a top priority.

Permission Tiers and the Skill System

On the feature side, Waveloom has a built-in tiered permission system that categorizes commands into three levels:

1. Auto-approve — safe commands with no side effects;
2. Require user confirmation — commands that may modify files;
3. Blocked — commands with dangerous side effects (e.g., deleting files).

This permission system is essentially a security sandbox for Agent tool calls. Granting an Agent file system and command execution access is a prerequisite for real productivity, but unconstrained permissions can lead to accidental code deletion or destructive commands. By predefining a whitelist, confirmation list, and blacklist, Waveloom strikes a balance between capability and safety.

In the demo, attempts by the Agent to run dangerous commands are intercepted — it cannot delete or tamper with data. Waveloom also includes a Web Fetch tool for retrieving web content and has solid compatibility with the Skill system — any Skills installed for Claude Code can be reused directly in Waveloom with virtually no migration overhead.

A Unique Advantage of Agent Development: Letting AI Test Itself

The author shares an insightful observation: Agent development is fundamentally different from conventional software development. Building features for an Agent means building tools it can call — and those tools are things the Agent can perceive and understand. Under the mainstream Function Calling standard, each tool comes with structured metadata: name, parameter definitions, expected return values, and so on. The Agent can read this like an API reference, understanding its own capability boundaries. So as long as each tool's inputs, outputs, and success criteria are defined upfront, the Agent can autonomously test its own toolset.

The author reveals that most of Waveloom's testing has been delegated to the Agent itself — he encapsulates test cases as Skills, defines test targets and pass criteria, and gets fully automated testing as a result. This is a major edge of Agent development over traditional development: testing itself becomes a task the Agent can understand and execute, forming a self-bootstrapping quality assurance loop.

That said, Agents do have limits. TUI interaction testing is one area they can't handle independently — the Agent can't perceive the visual rendering on screen or simulate keyboard focus switching, so a human must assist. In the demo, the Agent guides the author to manually trigger certain commands, switch themes or models, and observe whether the results match expectations — a human-Agent collaboration to validate the interaction layer.

Summary

Wavebloom embodies a clear product philosophy: going beyond general-purpose AI coding assistants by deeply customizing for DeepSeek to achieve extreme cost efficiency and a polished terminal experience. A nearly 99% cache hit rate (thanks to deep adaptation of DeepSeek's KV Cache mechanism), a lightweight TUI form factor, a stable flicker-free incremental rendering interface, and seamless compatibility with Claude Code Skills together define its competitive differentiation.

For developers who rely heavily on DeepSeek, are focused on reducing API costs, and are comfortable working in the terminal, this open-source tool — still in Alpha — is well worth watching. That said, Alpha status means features and stability are still being refined; thorough evaluation is recommended before using it in production.

Key Takeaways