npm install -g goatcode-cli

Why GoatCode?

Coding agents are great until they ask you to subscribe to them. GoatCode flips that: your terminal, your keys, your existing plans.

Not a comparison chart trick — every cell is a feature you can test in sixty seconds below.

Install

npm install -g goatcode-cli     # any OS with Node ≥16 — fetches the right binary

No npm? One line, picks your platform from the GitHub release:

# Windows (PowerShell)
powershell -c "irm https://raw.githubusercontent.com/Arhan-w/GoatCode/v2-typescript/install.ps1 | iex"

# Linux / macOS / Git-Bash
curl -fsSL https://raw.githubusercontent.com/Arhan-w/GoatCode/v2-typescript/install.sh | bash

Or grab a binary straight from the latest release: goat-windows-x64.exe · goat-linux-x64 · goat-linux-arm64 · goat-darwin-arm64 · goat-darwin-x64

Then:

goat auth            # pick a subscription OAuth flow or paste an API key
goat                 # you're in

Never stop coding

Your Claude quota dies at 2 AM mid-refactor? GoatCode retries the provider, then walks your fallback chain live — switches, says so, and finishes the answer. No crash, no lost context. The switch is sticky: the next launch starts on the provider that worked.

goat config set fallback-models '["openrouter/claude-sonnet","groq/llama-3.3-70b","deepseek/deepseek-chat"]'

Real capture — three 429 retries, the switch, then the full tool-call answer, one session:

This is a pty-captured recording of the actual TUI (real Ink renderer, real agent loop) — not a mock-up.

Background work gets its own budget too: set small_model and compaction + explore-subagents route to the cheap model automatically while your main turn stays on the frontier one.

See every change, rewind any mistake

Every write/edit prints a colored inline diff the moment it lands — and /rewind 4 puts the whole session (transcript and files) back to how it was at turn 4. Nothing is ever unrecoverable.

/rewind        # list recent turns to jump back to
/search oauth  # full-text search across every saved session
/model sonnet  # aliases — no need to remember model ids

Real capture — a write, its inline diff, and the live ctx meter in the footer:

Under the hood, long sessions get automatic prompt caching: the system prompt and tool definitions are cached between turns, so repeated context bills at 10% of input price. /cost shows exactly what the cache saved you this session.

Providers

180 in the built-in catalog, four wire formats (OpenAI, Anthropic, OpenAI-Responses, Gemini) — and any endpoint that speaks one of those dialects slots in with one command:

goat addp mypilot --base-url https://api.mypilot.example/v1 --api-key *** --models llama-4,qwq-32b
goat -m mypilot/llama-4 "refactor the auth module"

Keys can live in env (--api-key-env MY_PILLOT_KEY); list what resolves with goat providers --check.

Log in with subscriptions you already pay for

goat auth turns these into working API credentials via browser/device OAuth:

API-key providers (OpenAI, Anthropic, DeepSeek, Groq, Mistral, Together, Fireworks, xAI, OpenRouter, Moonshot, z.ai, Cerebras, Pollinations, Ollama, LM Studio, llama.cpp…) — set the usual env var (ANTHROPIC_API_KEY, OPENAI_API_KEY, …) or `goat auth --key ***

It actually drives your machine

The computer tool clicks, types, scrolls, launches apps, and reads what's on screen — vision included, screenshots go straight into the model. Permission-gated by default: every destructive action asks (or plan/bypass modes decide per-session).

> open the settings and tell me which extension is using the most disk

Reads are parallelized — a five-file exploration costs one round-trip, not five.

MCP · Skills · Plugins

• MCP servers — goat mcp add context7 npx -y @upstash/context7-mcp, or point at a remote http/sse server. Their tools land beside the built-ins.
• Skills — drop a SKILL.md into ~/.goatcode/skills/<name>/ (or the project's skills/<name>/); progressive disclosure keeps context lean. /skills lists everything loaded.
• Plugins — point "plugins": ["./my-plugin"] in config at a directory containing commands/<name>.md + skills/<name>/SKILL.md; /plugin lists what loaded, /plugin reload picks up edits.
• Hooks — Claude-Code-compatible PreToolUse/PostToolUse/Stop shell hooks: JSON on stdin, exit 2 blocks the action. Guardrails as code, not vibes.

And GOAT.md — project memory loaded into every session. /init writes the first draft from a real read of your codebase: commands, architecture, conventions with file:line examples, gotchas.

CI and scripts

Print mode is pipe-native and machine-readable:

cat error.log | goat -p "why did this fail?" --output-format json
# {"type":"result","is_error":false,"result":"...","session_id":"...","model":"...",
#  "usage":{"input_tokens":512,"output_tokens":42},"cost_usd":0.002166}

Sessions saved from -p runs are resumable (goat sessions, goat resume <id>, goat -c).

Cost, your way

/cost prices the current session live from the built-in rate table; /usage all aggregates every stored session by day and by model:

all time · 41 sessions · 1,284,113 in / 204,992 out tokens · $4.31
2026-09-11   8 sess    412,001 in     63,120 out   $0.42
...

Unknown models show honest zeros and a no price known note instead of a made-up number.

Slash commands

Keys: shift+tab cycles ask → accept-edits → plan → 🐐 GOAT MODE (bypass — every tool auto-approves, mid-turn, no prompts) · ctrl+t task panel · ctrl+v attach image · esc interrupt.

CLI

goat                          interactive TUI
goat -p "..."                 one-shot;  -q  quiet;  -m provider/model
goat -p --output-format json  machine output for scripts/CI
cat err.log | goat -p "why?"  stdin pipes in as context
goat -c                       resume last session
goat auth | providers | models | addp | endpoint | mcp | sessions | resume | config | self-update

goat self-update swaps the running binary for the latest release atomically — and the TUI shows an update hint the moment a release lands (cached, checks ≤ every 6 h).

Configuration

~/.goatcode/config.json (project override: goatcode.json), editable via goat config:

Env overrides win: GOAT_MODEL, GOAT_MAX_TOKENS, GOAT_MAX_STEPS, GOAT_AUTO_APPROVE, GOAT_TEMPERATURE, GOATCODE_HOME.

Under the hood

• Bun + TypeScript + Ink — one compiled binary per platform, no node_modules ever.
• Sandboxed tools — path containment to cwd, command allow/deny rules, undo stack for writes.
• Retry with jitter + retry-after honoring, request deadlines as retryable 408s, mid-stream error semantics that never duplicate partial output.
• JSONL sessions — append-only, compaction with model-written summaries (deterministic fallback), resumable everywhere.
• 87 tests, typecheck clean, CI on ubuntu + windows + macos on every push.

Development

git clone https://github.com/Arhan-w/GoatCode.git && cd GoatCode
bun install
bun run src/index.ts        # run from source
bun test                    # 87 tests
bun x tsc --noEmit          # typecheck
bun run compile             # single binary → dist/goat

Demo GIFs in this README are generated by docs/record_session.py + docs/render_frames.py — a pty-captured real TUI session against a deterministic mock provider, so captures stay reproducible. Contributions that keep that honesty are extra welcome.

FAQ

Is it free? Yes — MIT, $0 forever. You only pay whichever providers you choose (or already pay for). Can it actually use my Claude subscription? goat auth claude --oauth → browser login → credentials, done. What if a provider dies mid-session? Fallback chain handles it — see Never stop coding. Windows? First-class. irm | iex, native computer-use, ConPTY-tested TUI.

License

MIT — see LICENSE.