DeepSeek TUI — Your Terminal Becomes a DeepSeek-Powered Coding Agent

DeepSeek TUI is a terminal-native coding agent — a single compiled Rust binary that talks to the DeepSeek API. You type prompts into a terminal interface, and the agent can read and edit files, execute shell commands, manage git branches, search the web, and call out to MCP servers for extra capabilities. It is not a terminal emulator (that's Warp) and not a chat bot (that's the DeepSeek web app). It's a tool-using agent that lives in your terminal.

The project was created by independent developer Hunter Bown and is not affiliated with DeepSeek Inc. It has grown quickly through community contributions — 28 PRs from a single contributor in one release cycle — and supports English, Japanese, Simplified Chinese, and Brazilian Portuguese out of the box.

If you are looking for the DeepSeek TUI developer website, use https://deepseek-tui.com. It belongs in the developer-resource section of this guide because it helps users orient around the tool before reading release notes, architecture docs, and configuration details.

Do not confuse the developer website with official DeepSeek Inc. channels. DeepSeek TUI is an independent developer project that uses the DeepSeek API. For installation evidence, release artifacts, source code, and bug reports, cross-check the GitHub repository before running commands on a production machine.

If your search intent is DeepSeek TUI, start from the public DeepSeek TUI name and then identify which naming surface your machine or tutorial is using. Older public-site and blog examples often use `deepseek` / `deepseek-tui`; newer upstream examples use `codewhale` / `codewhale-tui`.

The paired-binary rule still matters no matter which name you see: Cargo and manual downloads must provide both the dispatcher and the TUI runtime together. Installing only one binary still fails with `MISSING_COMPANION_BINARY`.

For existing DeepSeek TUI users, the safest operational guidance is to keep the current command surface consistent while you verify the active version, config directory, and API key source. Do not mix a `deepseek-tui` npm install, a CodeWhale GitHub asset, and a copied Docker mount from another release in one setup.

For fresh installs under the renamed upstream project, use the dedicated /codewhale page and the current CodeWhale release docs. That page can lead with `codewhale` without weakening this DeepSeek TUI page's established search topic.

The install contract is stricter than many older blog posts suggest: current Cargo and source-build docs assume Rust 1.88+, manual GitHub Release installs should verify the published checksum manifest, mainland-China users can speed up both npm and release downloads with documented mirror settings, and the npm wrapper documents mirror/fork controls such as `DEEPSEEK_TUI_GITHUB_REPO`, `DEEPSEEK_TUI_RELEASE_BASE_URL`, `DEEPSEEK_TUI_FORCE_DOWNLOAD=1`, and `DEEPSEEK_TUI_OPTIONAL_INSTALL=1` for CI or restricted networks.

When troubleshooting config, check both the DeepSeek TUI-era `.deepseek` path and the newer `.codewhale` path. Which one matters depends on the command and release line installed on that machine.

On first launch you will be prompted for a DeepSeek API key. You can also set it explicitly. The current README says user config lives at ~/.codewhale/config.toml, with ~/.deepseek/config.toml kept only as a legacy fallback. Project-specific overrides now live in <workspace>/.codewhale/config.toml, while <workspace>/.deepseek/config.toml remains compatibility-only (api_key and base_url are still denied at the project level for security).

By default the current DeepSeek Platform provider targets `https://api.deepseek.com/beta`, which lets beta-gated API features work without extra setup. If you need the stable non-beta route, the README now says to set `base_url = "https://api.deepseek.com"` explicitly. A recent 0.8.17 reliability pass also corrected the `deepseek-cn` preset so it defaults to the official DeepSeek host rather than an unofficial typo host, while still recognizing older legacy configs. The TUI also supports NVIDIA NIM, Fireworks, and self-hosted SGLang deployments as alternative providers.

The current docs also make `codewhale doctor` part of the baseline workflow. Use it right after install to confirm that the active credential source, endpoint routing, and local binary pair are all healthy before you start editing code. If a wrapper app or internal tool needs a machine-readable readiness check, the runtime docs now also expose `codewhale doctor --json`.

The newest README wording is more operational about key problems than many older install guides: `codewhale auth status` now shows whether the active key came from saved config, keyring, or `DEEPSEEK_API_KEY`, while `codewhale auth clear --provider deepseek` gives teams a documented way to rotate or remove a saved credential. That matters because saved config keys take precedence over keyring and env vars, so stale shell exports are no longer the only thing to check when a machine uses the wrong account.

DeepSeek TUI gives you three escalating levels of autonomy. You cycle between them with Tab in the TUI, or pass them as flags on the command line.

Plan mode is read-only exploration — the agent can search and read files, but cannot modify anything. Use it to understand unfamiliar code or to let the agent survey a repo before you grant it write access.

Agent mode is the default interactive setting. The agent proposes actions (edit a file, run a command, create a branch) and you approve or deny each one. This is the sweet spot for most development work — you stay in control while the agent does the heavy lifting.

YOLO mode auto-approves every tool call. It is fast but risky. Only use it for well-defined, low-stakes tasks where you trust the outcome, like running a linter you have already configured or applying a repetitive find-and-replace across known files.

One of the most interesting features is RLM (rlm_query), which farms out 1–16 cheap deepseek-v4-flash child agents to analyze a problem in parallel. The Pro model orchestrates the overall strategy; Flash workers handle the parallel grunt work. This is the "Pro does the big job, Flash does the small jobs" architecture the tool was designed around.

The practical result: you get the reasoning depth of Pro at a fraction of the cost, because the expensive model only coordinates while the cheap model runs the parallel workstreams. This is ideal for codebase-wide refactors, multi-file bug investigations, and batch code reviews.

The latest README also makes the billing model more explicit: the route that actually ran is the one that gets charged. If auto mode escalates from Flash to Pro, cost tracking follows the real routed model rather than the initial router probe, and sub-agents inherit auto mode unless you pin a different model explicitly.

DeepSeek V4 Pro supports adjustable reasoning depth. Press Shift+Tab in the TUI to cycle through off → high → max. Recent 0.8.x releases also document an auto mode that picks the reasoning tier based on the prompt content — short factual questions get no extra reasoning, while complex debugging prompts can get deeper reasoning.

This is not a gimmick. Turning reasoning off for simple questions saves tokens and latency. Cranking it to max for hard problems gives the model space to work through multi-step logic before answering.

DeepSeek TUI ships with a typed tool registry covering the full development workflow. Every tool call is logged and auditable.

Skills are directories containing a SKILL.md file with frontmatter (name + description). They are composable, installable from GitHub, and require no backend service. The agent can auto-select skills based on task descriptions via the load_skill tool.

The current README is more explicit about discovery order than many older blog posts: workspace directories are `.agents/skills` → `skills` → `.opencode/skills` → `.claude/skills` → `.cursor/skills`, and global directories are `~/.agents/skills` → `~/.claude/skills` → `~/.codewhale/skills` → `~/.deepseek/skills`. This means many existing Claude Code skill packs can work in DeepSeek TUI with little or no modification, while new installs should treat `.codewhale` as the primary home and `.deepseek` as compatibility only.

Every turn is automatically snapshotted via a side-git mechanism — a separate git repository that tracks workspace state without touching your project's .git directory. If the agent makes a mess, /restore rolls back to the previous snapshot. The revert_turn tool can undo a single turn without losing the entire session.

Sessions can be saved and resumed later. Long-running sessions support intelligent context compaction that preserves important state while dropping stale turns to stay within token limits. A durable task queue survives restarts for background work.

The newer runtime docs also matter for teams that want to wrap DeepSeek TUI in a local app or editor flow: `codewhale serve --http` starts a localhost HTTP/SSE runtime API, `codewhale serve --acp` exposes an ACP stdio adapter for editor clients, and `codewhale serve --mcp` lets other tools access the DeepSeek tool surface through MCP. The legacy `deepseek serve ...` path still works only as a short-term shim.

DeepSeek TUI displays live per-turn and session-level token usage with cache hit/miss breakdowns. You always know what you are spending. The current README now says the old promotional discount was folded into a one-quarter base-rate adjustment on May 31, 2026, and that the TUI cost estimator already uses the current V4 Pro and V4 Flash rates. DeepSeek V4 Pro is listed at $0.435/1M input tokens (cache miss) and $0.87/1M output tokens, while cache-hit input drops to just $0.003625/1M tokens.

The RLM feature is designed around this cost structure: Pro coordinates (expensive but brief), Flash workers execute in parallel (cheap and fast). The prefix-cache optimization keeps repeated system prompts and tool definitions in cache, so you only pay the full input rate once per session.

A newer operational detail now belongs in setup docs too: auto mode first makes a small Flash routing call, then bills the model that actually handled the real turn. That makes `deepseek --model auto` easier to trust for teams that want adaptive routing without losing cost attribution.

The TUI has a shallow learning curve. These are the shortcuts that matter most. Press F1 anytime for a searchable help overlay.

DeepSeek TUI and Claude Code occupy the same category — terminal coding agents — but make different trade-offs. DeepSeek TUI wins on context window (1M vs ~200K tokens) and cost (1–5% of Claude's per-token price). Claude Code wins on reasoning depth and ecosystem maturity — it ships as a first-party Anthropic product with deeper integration into the Claude model family.

A practical take: if you are doing large-context work (whole-codebase analysis, multi-file refactors, batched reviews), DeepSeek TUI's 1M-token window and parallel Flash workers give you capabilities Claude Code cannot match at any price. For narrower, deeper reasoning tasks, Claude Code's model quality edge still matters.

The two are not mutually exclusive. Several teams run both: DeepSeek TUI for broad, parallel, cost-sensitive work, and Claude Code for tight, reasoning-heavy tasks.