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.
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.
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., /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
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 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.
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.