Klaat Code
A terminal-native AI coding agent with per-request smart model routing that delivers Claude Code-grade accuracy at roughly one-tenth the cost — reproducibly, not as a marketing claim.
- Source repo
- KlaatAI/klaatcode
- Stars
- ★ 353
- Last updated
- 1mo ago
- License
- NOASSERTION
- Primary language
- TypeScript
- FA score
- 61/100 · Some gaps
At a glance
- How it runs
- Works with
- Portable with changesOpenAI API (Partial support)
- Cost
- Free tier plus a paid hosted plan
- Setup effort
- Low · running in minutes
- You'll need
- Typical use
- Developers who want an agent that fixes type errors, refactors, and verifies its own edits in the terminal, with immediate lint/typecheck feedback after every file change
- Not a fit if
- Teams that need fully offline or locally routed intelligence — core routing runs only on KlaatAI's hosted service
- Users unwilling to accept vendor lock-in and quota-based billing for routing
- Buyers who require independently verified benchmark results
- Source review
- 61/100 · Some gaps
What does this agent do, and when should you use it?
Klaat Code is the open-source terminal coding agent from KlaatAI. Installed once, it operates in any project — reading code, editing files, running commands, and verifying its own work — while every request is classified and dispatched by the hosted Klaatu routing service across six cost tiers (nano/fast/code/reason/heavy/titan). The client is deliberately a thin terminal: routing decisions, model health tracking, pricing, and the code-graph index live server-side at klaatai.com. A real code knowledge graph with semantic search lets the agent query symbols, callers, callees, and blast radius instead of reading whole files, which the project claims cuts tokens 5–15× per task. The repo ships a reproducible benchmark harness (bun run bench), a full slash-command system, an MCP client (stdio and Streamable HTTP with OAuth 2.1), Git integration, skills, hooks, plugins, plus headless/CI and API-server modes. Licensed Apache 2.0, but core intelligence depends on the KlaatAI hosted service and requires signing in with a KlaatAI account.
After installing, you run klaatcode (or the alias klaatai) to open a session in the current directory; browser-based OAuth signs you into your KlaatAI account. The agent works through built-in tools: read_file, edit_file/multi_edit, apply_patch, glob/grep/list_dir, run_command (permission-gated), web_search/web_fetch, project_graph_query, plan_exploration, impact_check, delegate_task (optionally background sub-agents), todo_write/read, and five browser_* tools. Each request is classified by Klaatu and routed to a cost tier, auto-escalating when a task proves harder. After each successful edit it runs your project's typechecker/linter (auto-detecting eslint/biome, ruff, gofmt, rubocop, swiftlint, phpstan/pint, ktlint, shellcheck, or a custom command) and feeds errors back to the model for same-turn fixes. Sessions support mechanical compaction with snapshot-and-verify self-checks, /cost burn-rate monitoring and per-phase attribution, Git workflows (/diff, /review, /commit, /checkpoint, /rollback), MCP server management via .klaatai/mcp.json, /sessions and /resume transcript recovery, and headless automation via klaatcode run or an HTTP API via klaatcode serve.
- Developers who want an agent that fixes type errors, refactors, and verifies its own edits in the terminal, with immediate lint/typecheck feedback after every file change
- Cost-sensitive individual developers who want trivial questions billed at nano/fast tier prices and only genuinely hard problems escalated to frontier tiers
- Engineering teams automating lint fixes or security checks in CI, using klaatcode run with --max-cost and a KLAATAI_API_KEY GitHub Actions secret
- Engineers on large codebases who use the code call graph and impact_check to assess blast radius before changing anything, minimizing token usage
- Workflows that benefit from parallel sub-agents: delegate_task spins off background sub-agents while you keep chatting, with results injected via task_status
- Users with their own OpenAI-compatible endpoints who want to switch to a self-hosted model per session via /model add
How do you install or deploy this agent?
Any of: npm install -g klaatcode (requires Node >= 18 or Bun >= 1); or curl -fsSL https://klaatai.com/api/install | bash (macOS/Linux); or in PowerShell: irm https://klaatai.com/api/install-windows | iex; or brew install KlaatAI/klaatcode/klaatcode. All methods install a standalone compiled binary — no Node or Bun runtime required at runtime. On macOS EACCES errors, use sudo or fix npm's global prefix once.
How do you use this agent?
Run klaatcode login for browser OAuth sign-in (no API keys to manage); run klaatcode to open the current directory or klaatcode ~/projects/my-app for a specific project; use klaatcode run "Fix all TS errors" for headless mode. Key commands: /tier to lock or pick a routing tier, /cost for spend and burn rate, /mcp to manage MCP servers, /skill to invoke prompt templates, /init to generate project rules, Tab to switch Plan/Build mode. Shell completions for bash/zsh/fish are available via klaatai completions.
What are this agent's strengths and limitations?
- Smart per-request routing across six tiers: trivial turns pay nano/fast prices while hard problems auto-escalate to reason/heavy/titan; the published benchmark shows $0.027 per solved task — 5.4× cheaper than Claude Code (Sonnet 5) with a perfect 33/33 solve rate
- A real code knowledge graph with plan_exploration: querying symbols, callers, and blast radius instead of reading whole files, claimed to save 5–15× tokens per task
- Layered cost guards: burn-rate monitoring (warns at 3× session average), per-task and per-phase cost breakdowns, maxSessionCost hard cap, CI --max-cost, and a server-detected doom-loop breaker
- Unlimited free tool rounds — one user message equals one billable request, no Continue button; genuine stuck loops are detected server-side and broken with recovery guidance
- Detectable context compaction: task and file snapshots before summarizing, post-compaction verification, recovery notes telling the model what was lost and where to re-read; /context shows window contents
- Reproducible benchmark: clone the repo and run bun run bench to verify the cost/accuracy comparison against Claude Code, Cursor, opencode, and Grok Build yourself
- Core intelligence depends entirely on the hosted Klaatu routing service — routing logic cannot run locally, and offline use or service outage renders the agent inoperable
- Requires a KlaatAI account and OAuth sign-in; it is a commercial service with plans and quotas (titan tier is daily-capped), so adopting the CLI means accepting provider lock-in for routing and billing
- GitHub reports the license as NOASSERTION while the README claims Apache 2.0 — and the KlaatAI/Klaat Code/Klaatu names and logos are trademarked and excluded from the license; verify the actual LICENSE file before adopting
- Benchmark numbers are self-published by the project (latest run dated 2026-07-20); reproduction scripts are provided but independent third-party verification is absent
- Project-level semantic search is gated to the Pro plan, limiting code-retrieval capability on free accounts
How does this agent compare with similar options?
The README places it alongside Claude Code, opencode, Codex CLI, Aider, Cursor, and Grok Build, and benchmarks them on identical fixtures: on 33 tasks, Klaat Code solved 33/33 at $0.027/task (vs Claude Code's $0.146 — 5.4× cheaper) with a 23s median time; key differentiators versus Claude Code are free unlimited tool rounds (no Continue button) and a reproducible bench script. Cursor Composer 2.5 standard approaches its cost but is ~5× slower (~113s vs 23s median), so no rival is both cheap and fast, per the project's own harness.
Key facts side by side with the most closely related agents.
| Agent | Source review | Form / cost | Stars | Updated | Language | Full support on |
|---|---|---|---|---|---|---|
| Klaat Code This agent | 61 · Some gaps | CLIFreemium | ★ 353 | 1mo ago | TypeScript | — |
| Autohand Code CLI | 62 · Some gaps | CLIFree + model costs | ★ 210 | 2d ago | TypeScript | OpenAI API |
| Orca | 59 · Major gaps | CLIFree + model costs | ★ 508 | today | Rust | — |
| Synara | 52 · Major gaps | Desktop appFree + model costs | ★ 2.1k | today | TypeScript | Codex · Claude Code |
How does FollowAgents rate this agent?
Why each dimension lost points
The permission model (three-layer confirmation, allow once/session/always/deny, project-directory sandbox, hard-denied system paths, blocking before_tool hooks) is concretely documented in README and SECURITY.md, scoring 2; but every message goes to the closed-source Klaatu hosted service, whose routing/billing logic cannot be audited, and the curl|bash installer plus closed-source backend weaken least-privilege and dependency-security evidence (dependency_security only 1); /undo, /checkpoint, /rollback give a recovery path; the license carries trademark and copyright notices with clear attribution, but the unverified publisher caps this at 2.
CI runs typecheck, unit tests, bench selfcheck and build; /doctor diagnostics are documented; however package. contradicts README/LICENSE (license field MIT vs LICENSE Apache 2.0; package name klaatai vs npm klaatcode), deducted to 1; dependencies are few but no lockfile, audit or SBOM evidence is present (dependency_availability 1); error messaging is moderately documented (2).
Audience and scenarios are well covered: terminal developers, CI (--max-cost, GitHub Actions example), headless/API server/browser modes, BYOM via OpenAI-compatible endpoints, MCP, multi-platform install (3); capability boundaries (titan opt-in, read-only Plan mode, daily caps) are stated but partly rest on closed-source service behavior (2); trigger precision (tier routing, doom-loop detection) is specific but not statically verifiable (2); environment coverage across macOS/Linux/Windows with shell completions (2).
Information architecture is excellent — features, commands, config, and directory layout are clearly sectioned (3); install notes cover npm/script/Homebrew/Windows including an EACCES fix (3); naming is unstable — README promotes klaatcode while package.'s bin is klaatai, and the license field conflicts with the LICENSE file (1); examples are rich but no FAQ (2); known limitations are mostly deferred to external 'honesty notes' (1); license metadata is self-contradictory (NOASSERTION, MIT in package., Apache 2.0 in LICENSE) (1); CHANGELOG.md is referenced but absent from evidence, so versioning claims for 2.5.0 are uncorroborated (1); maintenance responsibility has SECURITY.md response SLAs and routing (2).
Output usability is heavily specified (diff rendering, streaming, session export) (2); marginal-value claims (per-request routing, cost guards, code graph) are concrete and compared against rivals, but rest on closed-source server-side implementations (2); cost-benefit is quantified with a reproducible bench script, though the benchmark results themselves cannot be statically verified (2).
Benchmark claims ship with methodology and repro commands (claim_traceability 2); core claims (server-side routing, free tool rounds, performance numbers) depend on a closed backend and external site and cannot be corroborated within the repo (1); fact/inference separation is decent — 'est' figures are labeled, honesty notes are linked, the PR bot is explicitly advisory-only (2).
- All conversations and code context are sent to the closed-source Klaatu hosted service; routing and billing logic are unauditable — assess data-egress risk for sensitive codebases.
- The recommended install path executes a remote script via curl|bash, a higher supply-chain risk than npm install alone.
- License metadata is self-contradictory (NOASSERTION registry tag, MIT in package., Apache 2.0 in LICENSE); confirm actual terms and trademark restrictions before use.
- Benchmark and '5.4× cheaper' claims rest on a closed-source server and self-authored fixtures and cannot be statically verified from the repo — run the bench yourself before relying on them.
- Inconsistent naming (klaatcode vs klaatai) and an unverifiable CHANGELOG reference mean the npm-package-to-repo mapping should be confirmed independently.
Recent releases
Latest entries from the project's GitHub Releases. Notes are quoted from upstream as written, not rewritten or tested by FollowAgents.
-
V2.5.0 KlaatCode 2.5.0
Release notes excerpt
KlaatCode 2.5.0 The release where the agent stops grepping around your project and starts *knowing* it. Added - Code graph, everywhere. Your project is indexed into a local code graph (tree-sitter quality, all plans including free) and the agent navigates with it: project_graph_query answers "where is X / what calls Y" with exact file:line, file_outline reads a file's structure for ~10% of the tokens, read_file symbol="Name" serves exactly one definition, impact_check shows the blast radius before an edit, and plan_exploration returns the optimal read order for a task. …View on GitHub ↗ -
V2.4.4 KlaatCode V2.4.4
Release notes excerpt
KlaatCode v2.4.4 Reliability patch — four fixes for turns that stalled or showed garbage mid-task. Fixed - multi_edit no longer dies on redundant sub-edits — if one edit in a batch has identical old_string and new_string, it is skipped as a no-op and the rest apply. Previously a single redundant edit (e.g. 1/12) aborted the whole batch and stalled the turn. Genuinely mismatched edits still abort atomically with nothing written. …View on GitHub ↗ -
V2.4.3 KlaatCode V2.4.3
Release notes excerpt
Klaat Code v2.4.3 Klaat Code now updates itself. Run klaatcode and it checks for a newer release before anything else, asks once, and gets out of your way. --- ⬆️ Update on launch ``` Update available: v2.4.2 → v2.4.3 Update now? [Y/n] ``` Yes → upgrades through whichever channel installed it (npm, Homebrew, install script, PowerShell installer), then relaunches with your original arguments so you land where you were going. No → it won't ask again for that release. …View on GitHub ↗