Whale is a DeepSeek-only coding agent, and its headline number ships without a table

Five install paths, two of which pipe a script into your shell

The quick start offers one path per platform shape, and only the first is a package manager:

npm install -g @usewhale/whale

brew install usewhale/tap/whale

curl -fsSL https://raw.githubusercontent.com/usewhale/Whale/main/scripts/install.sh | sh

The Linux line downloads a shell script from the repository's `main` branch and hands it to `sh` without saving it first, which means the code that runs is whatever that branch holds at the moment you paste it. The Windows paths are the same idea with a PowerShell pipeline, and the command line variant goes further by asking PowerShell to bypass its execution policy:

powershell -NoProfile -ExecutionPolicy Bypass -Command "irm https://raw.githubusercontent.com/usewhale/Whale/main/scripts/install.ps1 | iex"

Windows support is stated as Windows 10 or Windows Server 2016 or later. After installation, two commands matter: `whale setup` stores the DeepSeek API key, and `whale` opens the interactive TUI. The point to keep in mind is that the two script paths and the two package manager paths fetch different artifacts, and the documentation does not say how the versions line up.

The 98 percent cache claim has no table beside it

The cache claim appears twice at the top of the front page, once in the one-line summary and once in the At a Glance table, which explains that most prompts hit cache and says that this slashes costs to pennies per session. No figure, method, prompt set or cost comparison appears anywhere near that number.

The tree does contain the instrument. There is a `bench/` directory at the root, and the Makefile exposes two targets that run a shell script:

bench-cost:
	@scripts/bench/cost.sh

bench-cost-live:
	@scripts/bench/cost.sh --live

One target runs the script as it is and the other adds a live flag, so the project can measure what a session costs offline and again against the live service. Neither target prints anything in the documentation, and no recorded result is checked in, so the headline number has no published counterpart.

What makes caching central rather than incidental is the DeepSeek-only decision. Not being a multi-model shell is listed as a non-goal, and the agent is described as built for DeepSeek's long context of 1M tokens, its tool calling, and its pricing. If a request misses the cache, there is no second provider inside the tool to fall back to.

Dynamic workflows run on QuickJS and ship switched off

Workflows are JavaScript files that orchestrate several agents, and the example is short enough to read in one breath:

// .whale/workflows/research.js
const results = await parallel([
  () => agent("Search for best practices in Go error handling"),
  () => agent("Find common Go error handling mistakes"),
]);
return agent("Synthesize both findings into a concise guide");

Two globals do the work: `parallel` takes an array of thunks and `agent` takes a prompt string and returns a result, so a fan-out research pass followed by a synthesis pass is the whole pattern. The listed uses are fan-out research, multi-perspective review, pipeline processing and adversarial validation.

The credits name `fastschema/qjs` as the QuickJS Go bindings, which means the scripting engine is an interpreter embedded in the binary rather than Node. The catch is the default: workflows are disabled until you run `/config` in the TUI and enable Dynamic workflows, or add `[workflows] enabled = true` to `.whale/config.local.toml`. Scripts are also stated to be Claude Code compatible, which is why the example uses no imports and no module syntax. The useful part is the shape, and the runtime underneath is Whale's own.

A second binary is built that no interface table mentions

Three interfaces are documented, and the third is the reason to read the Makefile:

| Interface | When to use | |---|---| | `whale` (TUI) | Interactive coding sessions with full context | | `whale ask "..."` (CLI) | One-shot questions, quick reviews, single commands | | `whale --headless` | CI/CD, automated PR reviews, scheduled tasks |

The Makefile builds something else. `build-acp` compiles a second executable, `bin/whale-acp`, from `./cmd/whale-acp/`, and the tree has that directory. Nothing in the interface table, and nothing in the quick start, explains what the ACP binary is or when you would run it.

The Windows handling around those binaries is uneven. A conditional at the top of the Makefile sets `BIN ?= bin/whale.exe` on `Windows_NT` and `bin/whale` everywhere else, then exports the variable so the build helper picks it up. The `build-acp` target ignores that variable and writes a literal `bin/whale-acp`, without the `.exe` suffix the rest of the file bothers to add for Windows.

Version stamping runs through the same file: `VERSION ?= dev` plus a linker flag writing into `internal/build.Version`. A local build therefore reports itself as `dev`, while the tags say `v0.1.66`.

Every Makefile target is a Go program you cannot read from the Makefile

The build file is a shim. `help`, `build`, `fmt-check`, `vet`, `test`, `test-evals`, `test-tui`, `test-windows`, `run` and `clean` all do the same thing, which is call a helper in the repository with `go run ./cmd/dev` and a subcommand. The only targets with real commands in them are `build-acp` and the two benchmark wrappers.

That has a consequence for anyone trying to work out what the test suite covers. The names hint at it: a default `test`, a `test-evals` target, a `test-tui` target for the terminal interface, and a `test-windows` target that exists as its own entry point rather than as a conditional inside another one. The actual commands, flags and markers live in Go code under `cmd/dev`, so the split between unit tests, prompt evaluations and interface tests is visible only by reading that helper.

Two defaults matter for a fork. The Go build cache is redirected to `$(CURDIR)/.gocache` and exported, which keeps build artifacts inside the checkout, and the toolchain floor comes from `go.mod`, which declares `go 1.26.2`.

The module path is lowercased while every public link says Whale

`go.mod` declares the module as `github.com/usewhale/whale`, all lowercase. Every public reference in the documentation uses the capitalised repository name instead: the release badges, the npm package `@usewhale/whale`, the installer URLs under `github.com/usewhale/Whale/main/scripts/`, and the repository title in the heading.

GitHub treats the two as the same repository, but a Go module path is case-sensitive, so the path you write in an import has to match the lowercase form declared in `go.mod` while the path you click is the mixed case one. Anyone vendoring Whale as a library, or writing a `replace` directive, has to be precise about which spelling goes where.

The rest of the dependency list is small and legible for a terminal application: Bubble Tea, Lip Gloss, Glamour and bubbles for the interface, cobra with pflag for the command line, chroma for syntax highlighting, goldmark for Markdown, the MCP Go SDK at version 1.5.0, `creack/pty` and `erikgeiser/coninput` for terminal control, BurntSushi/toml for configuration, and `fastschema/qjs` for the workflow engine. The credits also name a pure-Go WebAssembly runtime, without saying which named feature runs on it.

Five extension mechanisms, and a lockfile for one of them

Extensibility is a table of five rows rather than one plugin system: MCP servers for external tools, skills that load domain knowledge such as code review or git worktree flows, subagents that define focused child roles, plugins that extend the runtime, and hooks that run scripts on lifecycle events. Each row links to its own page under `docs/`, and MCP is described as connecting to more than a thousand servers.

The repository root shows how two of those are pinned. There is a `skills-lock.json` next to `go.mod`, so installed skills are locked the way dependencies are, and there is an `AGENTS.md` plus an `.agents/` directory, which is the convention agents use to carry their own instructions.

Two boundaries are stated as non-goals. Whale is not a multi-model shell, and it is not an IDE replacement; the stated position is that it meets you in the terminal, on the desktop or in CI. A provider switch, a proxy or a custom configuration is handled in a separate configuration page rather than in the main flow.

The project also states it is not affiliated with DeepSeek Inc. and is an independent community project, which matters given how much of the design is tuned to one vendor's caching and pricing.

The status section sets the expectation the tags support

The front page calls Whale a project in active development and says it is best suited to personal projects, experimental repositories, and workflows where changes can be reviewed and rolled back. The repository agrees with that framing in the version numbers rather than in adjectives: the tags are `v0.1.66`, `v0.1.65` and `v0.1.64`, dated 2026-08-11, 2026-08-06 and 2026-08-05, so this is a pre-1.0 series shipping patch releases several times a week at the end of that window.

The repository is not archived, and its last push is dated 2026-08-11, which is also the date of the newest tag. Nothing in the metadata suggests a 1.0 release, and the interface table still says more environments are on the way.

The practical reading is that this is a fast-moving pre-1.0 binary that expects you to read a configuration page and a workflows page before the quick start tells you anything, and that the rollback-friendly paths it names, reviewed and reverted changes in a repository you control, are the reason it positions itself that way.

Editorial conclusion

Whale is worth a look for someone who already pays for DeepSeek and wants a single binary agent in the terminal, with the caveat that the DeepSeek-only design is a deliberate exclusion rather than a missing feature. Verify three things first: the install path you trust, since two of the five pipe a remote script straight into a shell or into PowerShell with the execution policy bypassed; whether you need dynamic workflows switched on by hand, because they ship disabled; and the cache hit claim, which the repository has tooling to measure and no published result to read. Treat it as what the README calls it, a project best suited to personal or experimental repositories where changes can be reviewed and rolled back.

Frequently asked questions

Official sources

1. License: MIT
2. Project website
3. README
4. Releases
5. usewhale/Whale on GitHub