Tau: a multi-provider coding agent that bundles Claude Code and OpenCode behaviours
You’re adaptive AI assistant for your work.
At a glance
- What is it?
- Tau is a TypeScript CLI coding agent that ships native adapters for 28 model providers and folds in LSP diagnostics, shadow-git snapshots, a Python kernel and browser automation. The README makes large claims; here is what it actually commits to, and where the documentation stops.
- Who is it for?
- Adopt Tau if you already hold API keys for several providers and want one agent loop over all of them, or if you need the Python eval tool and LSP diagnostics in the same process. Do not adopt it if you need a settled licence, a documented security model for the remote-control tunnels, or a stable release line: the version numbers are still in the 0.92 range.
- Can I use it commercially?
- Not without permission. GitHub finds no licence file in the repository, and without a licence all rights are reserved by default: you may read the code but not reuse it. Check the README, or ask the authors, before using it.
- Is it still maintained?
- Yes. The repository last received commits 1 day ago.
- What is it written in?
- Mainly TypeScript, 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 provider lock-in problem Tau is aimed at
Most coding agents assume you have already picked a vendor. The README states the motivation directly: the leading agents either lock you into a single subscription, gate features behind enterprise tiers, or bill per token, and a rate limit on one provider stops the day. Tau's answer is to run the agent loop itself and talk to whichever provider you hold credentials for. The README claims you can work with a provider without that provider's official tool installed, naming Codex CLI, Antigravity, Cline, KiloCode, Kiro and Copilot as things you do not need on disk. That is the specific problem: one CLI, many backends, no per-vendor client to maintain. The audience is developers who already pay for one or more model APIs and want a single interface over them, rather than people looking for a hosted product with a support contract.
Native adapters rather than a routing proxy
The architectural choice the README stresses is that Tau is not a translation layer. Each provider gets its own adapter, and the README says OpenAI calls go to OpenAI's API directly, with the same arrangement for GLM, DeepSeek, Mistral, OpenRouter, AgentRouter, Vercel AI Gateway, Requesty, Command Code, MiniMax and OpenCode Zen. The claimed consequence is per-provider handling of streaming, rate limits and tool-schema sanitization, which is the part a generic proxy usually gets wrong because tool-call schemas differ between vendors. Twenty-eight adapters is a maintenance surface, and the README does not describe how adapters are versioned or how a provider's breaking API change is absorbed. That is the trade-off: direct adapters buy fidelity and cost you a wider surface to keep current. The full list and per-provider notes live in PROVIDERS.md, which is not reproduced in the material available here, so I cannot verify which 28 providers are covered or what caveats each carries.
Installing and launching Tau
The documented install is a single npx invocation: `npx -y @abdoknbgit/tau-installer@latest`. Requirements listed are Node.js 20.19+ or 22.12+ (for require(esm) support), Git, Bash, `gh` for GitHub automation, and Go 1.25.8+ if you want to build the optional native helpers from source. After install you run `tau` to launch, and `tau update` to update. The README describes a first-run wizard: type `/login`, pick a provider, and credentials are saved, with no shell exports or environment variables to set by hand. Two launch and mode switches are documented: `tau --dangerously-skip-permissions` to skip permission prompts, and inside the session `/mode cheap` for a compact cache-stable core with bounded tool output versus `/mode normal` for your configured tools. `/models` browses and switches the active model; `/tools` toggles optional tools. The Go requirement is worth reading twice: it is only for building native helpers, but it means a source build pulls a second toolchain into your environment.
LSP, snapshots and the eval kernel inside the loop
Three features distinguish Tau from a plain chat-with-tools wrapper. First, LSP support is built in: the agent reads diagnostics, definitions, references and hover data from project language servers for TypeScript, Python, Bash and YAML without spawning external editor tooling, and the README treats type errors, unused symbols and cross-file references as signal in the loop rather than something you paste in. Second, per-turn snapshots go into a shadow git repository separate from your project's `.git`, with `save`, `list`, `diff` and `restore` operations, files over 2 MB auto-excluded and weekly garbage collection. Because it is a separate repository, restoring does not touch your branches, which is a cleaner design than stashing into the working tree. Third, the `Eval` tool runs a persistent Python kernel that keeps state between cells, can call other Tau tools from inside the code, and renders figures inline. The README's framing is that you compute counts, rankings and cross-file audits instead of reading raw material into context. That is a real architectural difference: it moves some work out of the token budget and into a process.
Remote control, browser automation and named subagents
Tau exposes the session over HTTP for phone control. `/remote local` serves it on your own Wi-Fi, so nothing leaves the network. `/remote global` opens a Cloudflare HTTPS tunnel that works on cellular and requires `cloudflared` installed. You pair by scanning a QR code, then read, prompt and approve tool calls from the phone while execution stays on your machine. There is also `/whatsapp` for linking WhatsApp as a control channel. Browser automation drives a real Chrome window with clicks, typing, scrolling and form fills, and the README says simple pages are read over plain HTTP with Chrome starting only when a page needs it. Two subcommands are named: `measure` reports rendered colors, font fallbacks, contrast, broken images and overflow, while `extract` pulls repeating rows along with the selector behind each value, and console and network output come back with the page. Subagents are addressable: `Agent(name: "auth-fix", ...)` spawns work, and `SendMessage(to: "auth-fix", "...")` continues it with context intact. Each spawn can run on its own provider and model, and concurrent agents take write-ownership of the files they edit.
What the documentation leaves open
The licence field is empty in the repository metadata, and the README links a licence badge from npm rather than stating terms. Until you open the LICENSE file yourself, you cannot know whether redistribution or commercial use is permitted, and this article cannot tell you. The remote-control surface deserves the same scrutiny: `/remote global` publishes your session through a Cloudflare tunnel, and the README does not describe authentication beyond QR pairing or what is exposed while the tunnel is open. The `--dangerously-skip-permissions` flag is named for a reason. Beyond that, the project is on a 0.92.x line with releases roughly days to weeks apart (v0.92.24, v0.92.25, v0.92.28 across late August and early September 2026), which suggests interfaces may still move. There is no stated support policy, no compatibility table for the 28 adapters, and no published benchmark of token consumption for `/mode cheap`. The README's opening claim that Tau has become the best free coding agent is a marketing statement, not a measurement, and should be read as such.
How this compares to Cline and similar editor agents
Cline is the closest comparison point named in the material. Cline is an agent that runs inside an editor and depends on that host for its tool surface and its file access, which means the editor's language services and the editor's UI are part of the loop. Tau inverts that: it is a terminal binary that carries its own LSP client, its own snapshot store and its own browser driver, so it does not need an editor running to get diagnostics or to undo a change. The cost of the inversion is that you get a CLI, not a panel, and every integration Tau supports has to be built and maintained inside Tau rather than inherited from the host. The README also positions Tau against the vendor CLIs (Codex, Copilot, Antigravity, KiloCode, Kiro) on the grounds that you do not install them. That is a genuine difference in approach for anyone who wants one agent process over several paid APIs, and it is not a difference that matters if you have standardized on a single vendor and are happy with its client.
Maintenance, upgrade path and who this is for
Updates are handled by `tau update`, and the release cadence visible in the material is frequent: three releases in the two weeks before the last push. That cadence cuts both ways. You get fixes quickly, and you also inherit whatever changed between v0.92.24 and v0.92.28 without a changelog in the supplied material. The Go 1.25.8+ requirement means native helpers built from source need re-checking when the toolchain moves, and the 28 adapters mean a provider-side API change can land in your workflow without a Tau release note you were watching for. On licensing, the only honest statement is that the terms are unknown from the metadata provided; if you plan to vendor Tau into a product or run it inside a regulated environment, read the LICENSE file and the npm package metadata before you commit. Tau fits a developer who holds keys for two or more providers, wants the Python eval path and LSP diagnostics in one process, and is comfortable on a pre-1.0 CLI. It does not fit a team that needs a frozen interface, a documented threat model for remote session access, or a licence they can cite without opening the repository.
Editorial conclusion
Adopt Tau if you already hold API keys for several providers and want one agent loop over all of them, or if you need the Python eval tool and LSP diagnostics in the same process. Do not adopt it if you need a settled licence, a documented security model for the remote-control tunnels, or a stable release line: the version numbers are still in the 0.92 range. Before installing, read LICENSE in the repository, check whether the 28 adapters in PROVIDERS.md include the provider you actually pay for, and confirm that Node 20.19+ or 22.12+ plus Go 1.25.8+ are present if you intend to build the native helpers.
Community notes