Goose vs Claude Code: Free Agent, Same Job

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 without a subscription. It's an open-source, model-agnostic coding agent that runs on your machine — with a local model there are no subscription fees, no usage caps, and no cloud dependency: your code never leaves your laptop. (Point it at a cloud model and normal API usage charges apply.)

The project has ≈54,000 GitHub stars as of September 2026 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, in a market where agent coding tools are consolidating fast.

What Claude Code Costs (and What You Actually Get)

Claude Code's pricing structure is straightforward but restrictive. The Free plan doesn't include Claude Code — it covers chat only. 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 the flagship Opus model of that lineup (Claude 4.5 Opus in the August 2026 pricing; Anthropic's model lineup has since moved to generation 5 — check current availability).

The weekly rate limits add another layer, as documented in the August–September 2026 pricing. 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. One independent estimate puts the actual per-session limits at roughly 44,000 tokens for Pro and 220,000 tokens for the $200 Max plan. Model generations have since moved on — treat all of these figures as a snapshot of that pricing era, not current limits.

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 stated 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. That power is exactly why agent tool permissions deserve their own threat model.

The tool calling quality depends on the underlying model. Independent rankings such as the Berkeley Function-Calling Leaderboard, which scores models on translating natural language into executable calls, are worth checking when you choose which model to point Goose at.

Picking the Model Behind Goose

Three filters, all from the facts above. First, tool-calling quality: check the BFCL ranking, because a model that fumbles function calls wastes every other advantage. Second, context versus memory: a bigger window holds more codebase without chunking, but local models trade window size against memory and speed — size the model to the machine, not the benchmark. Third, cost shape: prompt caching cuts repeated-context input costs dramatically on hosted models, while a local model costs nothing per token after setup. There is no best model here, only a best fit for the machine and the budget in front of you.

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 — and that same MCP surface is where tool poisoning lives.

# 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 — a plugin-style philosophy shared by open-source agent frameworks. 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's flagship Opus model 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: current Claude models (Sonnet 5, Opus 5) offer one-million-token context windows — 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 (cache reads cost 10% of the base input price, cutting up to 90% off repeated-context input costs) and structured outputs are well-documented and reliable. Goose, while actively developed with 150+ releases as of September 2026, 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 Lock-in Ledger

Restate the pricing facts above as vendor risk. Prompts per window (10–40 on Pro, up to 800 on Max) cap your busiest days. Weekly token-hours cap your busiest weeks. The 5% defense is ambiguous about its own denominator. None of these are secret — they are the published terms — but together they describe a workflow whose ceiling moves at one vendor's discretion. This is what vendor lock-in looks like before it bites; after it bites, it looks like a cutoff notice.

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. With a local model, Goose is a zero-cost, privacy-preserving alternative that 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/aaif-goose/goose. Ollama is at ollama.com. Both are free and open source.

Sources

• Agentic AI Foundation: Goose — GitHub repository (stars, providers, extensions, license)
• Agentic AI Foundation: Goose — Releases
• Anthropic: Anthropic — Pricing (Free excludes Claude Code)
• Anthropic: Anthropic — Use Claude Code with your Pro or Max plan
• Anthropic: Anthropic — Models overview (1M context on current models)
• Anthropic: Anthropic — Prompt caching (cache reads at 10% of base input price)
• UC Berkeley Gorilla Lab: Berkeley Function-Calling Leaderboard