Goose vs Claude Code: Free Agent, Same Job

Claude Code is the most capable AI coding agent available. It reads your codebase, writes code, runs tests, deploys changes, and handles multi-file refactors with minimal supervision. It's also expensive — the Max plan runs $200 per month, and even the $20 Pro plan caps you at 10 to 40 prompts every five hours. Hit your limits during an intensive coding session and you're stuck waiting.

Goose, built by Block (formerly Square) and now governed by the Linux Foundation's Agentic AI Foundation, does the same job for free. It's an open-source, model-agnostic coding agent that runs entirely on your machine. No subscription, no rate limits, no cloud dependency. Your code never leaves your laptop.

The project has 48,000+ GitHub stars and ships as both a desktop app and CLI. It's Apache-2.0 licensed, actively maintained, and supports 15+ model providers including Ollama for fully local operation. The comparison to Claude Code isn't hypothetical — it's the comparison developers are making right now.

What Claude Code Costs (and What You Actually Get)

Claude Code's pricing structure is straightforward but restrictive. The free tier gives you nothing. The Pro plan ($20/month) limits you to 10-40 prompts per five-hour window. The Max plans at $100 and $200 per month offer 50-200 and 200-800 prompts respectively, plus access to Claude 4.5 Opus.

The weekly rate limits add another layer. Pro users get 40-80 hours of Sonnet 4 usage per week. Max users at $200 get 240-480 hours of Sonnet 4 plus 24-40 hours of Opus 4. But these "hours" are token-based limits that vary depending on codebase size and conversation complexity. Independent analysis suggests the actual per-session limits translate to roughly 44,000 tokens for Pro and 220,000 tokens for the $200 Max plan.

Developers have been vocal about the frustration. Some report hitting daily limits within 30 minutes of intensive work. Others have canceled subscriptions entirely, calling the restrictions unusable for real development work. Anthropic's defense — that the limits affect fewer than 5% of users — hasn't resolved the anger, partly because the company hasn't clarified whether that's 5% of Max subscribers or 5% of all users.

How Goose Works (and Why "Any LLM" Matters)

Goose takes a fundamentally different approach. It's a command-line tool or desktop app that runs locally and connects to whatever language model you choose. The "any LLM" part is the key differentiator.

You can point Goose at Anthropic's Claude models if you have API access. You can use OpenAI, Google Gemini, Groq, OpenRouter, or Azure. Or you can run it entirely locally with Ollama, downloading and executing open-source models on your own hardware. With a local setup, there are zero subscription fees, zero usage caps, and zero concerns about code leaving your machine.

# Install Ollama and pull a coding model
ollama run qwen3-coder

# Install Goose (macOS example)
brew install block/tap/goose

# Configure Goose to use Ollama
goose configure
# → Select "Configure Providers" → "Ollama" → http://localhost:11434

The practical implications go beyond cost. Goose works offline — on planes, in air-gapped environments, anywhere without internet. Your conversations with the AI never leave your machine. For developers working on proprietary codebases, regulated projects, or sensitive infrastructure, that's not a nice-to-have. It's a requirement.

What Goose Can Actually Do

Goose isn't a code completion tool. It's an autonomous agent that can build entire projects from scratch, write and execute code, debug failures, orchestrate workflows across multiple files, and interact with external APIs. It uses tool calling — the ability for a language model to request specific actions from external systems — to actually execute operations, not just describe them.

The tool calling quality depends on the underlying model. Claude 4 models from Anthropic currently lead the Berkeley Function-Calling Leaderboard, which ranks models on their ability to translate natural language into executable code and system commands. But open-source models are catching up fast.

Goose integrates with the Model Context Protocol (MCP), connecting to 70+ extensions covering databases, APIs, browsers, GitHub, Google Drive, and more. Through MCP, Goose can access tools far beyond what the base language model provides.

# Example Goose recipe — parameterized workflow
name: test-and-deploy
description: Run tests, build, and deploy to staging
steps:
  - tool: terminal
    command: "npm test"
  - tool: terminal
    command: "npm run build"
  - tool: github
    action: create_pr
    branch: "staging-{{version}}"

Recipes turn agent workflows into shareable, parameterized YAML that can run in CI/CD pipelines. This is the kind of feature that makes Goose useful beyond individual development — it becomes a team automation tool.

The Trade-offs You Should Know About

The honest comparison requires acknowledging what Claude Code does better.

Model quality: Claude 4.5 Opus remains arguably the most capable AI for complex software engineering. It excels at understanding large codebases, following nuanced instructions, and producing high-quality code on the first attempt. Open-source models have improved dramatically, but a gap persists for the most challenging tasks.

Context window: Claude Sonnet 4.5 offers a one-million-token context window — enough to load entire large codebases without chunking. Most local models default to 4,096 or 8,192 tokens, though many can be configured for longer contexts at the cost of memory and speed.

Out-of-box polish: Claude Code benefits from Anthropic's dedicated engineering. Features like prompt caching (reducing costs by up to 90% for repeated contexts) and structured outputs are well-documented and reliable. Goose, while actively developed with 102+ releases, relies more on community contributions.

Tooling maturity: Claude Code has skills, subagents, hooks, and background execution built in. Goose is catching up, but the integration between Anthropic's models and Claude Code's harness is tighter than what you get with Goose's model-agnostic approach.

The Real Question: Control vs Convenience

The comparison between Goose and Claude Code reduces to a single axis: who owns your workflow?

Goose is Apache-2.0, Linux-Foundation-governed, and model-agnostic. You can fork it, self-host it, swap models freely, and your workflow isn't hostage to any one company. The price of that freedom is more setup friction and the need to manage your own model provider connections.

Claude Code is proprietary, tightly-integrated, and optimized for Anthropic's frontier models. You sign in and go. The trade-off for that polish is tighter coupling to one vendor's models, pricing, and roadmap.

Many developers are choosing to run both. Goose as the vendor-neutral workhorse for everyday tasks and sensitive codebases. Claude Code when they specifically want Anthropic's frontier model in the smoothest available harness. Running both hedges the biggest risk: betting your entire workflow on one lab's model and pricing.

Getting Started with Goose

The fastest path to a free coding agent:

1. Install Ollama and pull a model (ollama run qwen3-coder)
2. Install Goose (desktop app or CLI)
3. Configure Goose to connect to Ollama at http://localhost:11434
4. Start coding

For developers who want cloud models, Goose connects to Anthropic, OpenAI, Google, and 12+ other providers through API keys. You can also use your existing Claude or ChatGPT subscriptions via the Agent Client Protocol.

The $200-per-month era for AI coding tools may not be ending, but it's no longer the only option. Goose proves that a zero-cost, privacy-preserving alternative can handle real development work. Whether it replaces Claude Code entirely or becomes the complement that fills its gaps depends on what you optimize for — and increasingly, developers are choosing both.

Goose is available at github.com/block/goose. Ollama is at ollama.com. Both are free and open source.