The artificial intelligence coding revolution comes with a catch: it’s expensive.

Anthropic, a prominent artificial intelligence company, introduced Claude Code, a terminal-based AI agent designed to autonomously write, debug, and deploy software. This sophisticated tool quickly captivated software developers globally with its promise to revolutionize coding workflows. However, its pricing structure—ranging from $20 to $200 per month depending on usage—has ignited significant discontent among the very programmers it aimed to empower.

Amidst this frustration, a compelling free alternative is rapidly gaining traction. Goose, an open-source AI agent developed by Block (the financial technology company formerly known as Square), offers functionality nearly identical to Claude Code. Crucially, Goose operates entirely on a user’s local machine, eliminating subscription fees, cloud dependencies, and restrictive rate limits that plague commercial offerings.

"Your data stays with you, period," affirmed Parth Sareen, a software engineer, during a recent livestream demonstration of Goose. This statement encapsulates the project’s core appeal: it grants developers complete control over their AI-powered workflow, including the invaluable ability to work offline, even in environments like an airplane.

Goose’s popularity has soared since its launch, evidenced by over 26,100 stars on GitHub, the premier code-sharing platform. The project boasts a robust community of 362 contributors and has seen 102 releases, with the latest version, 1.20.1, shipped on January 19, 2026. This rapid development pace underscores its vibrancy and commitment to continuous improvement, rivaling that of many commercial products. For developers increasingly burdened by Claude Code’s pricing and usage restrictions, Goose stands out as a rare, genuinely free, and unconstrained option for serious development work.

Anthropic’s New Rate Limits Spark a Developer Revolt

To fully appreciate Goose’s significance, one must understand the controversy surrounding Claude Code’s pricing and usage limits. Anthropic, a San Francisco-based AI firm founded by former OpenAI executives, integrates Claude Code into its various subscription tiers. The free plan offers no access to Claude Code whatsoever. The Pro plan, priced at $17 per month with annual billing (or $20 monthly), severely restricts users to a mere 10 to 40 prompts every five hours—a limitation many professional developers report exhausting within minutes of intensive coding.

Higher-tier Max plans, costing $100 and $200 per month, provide more substantial allowances: 50 to 200 prompts and 200 to 800 prompts respectively, along with access to Anthropic’s most powerful model, Claude 4.5 Opus. Yet, even these premium subscriptions come with restrictions that have inflamed the developer community.

The situation escalated in late July when Anthropic introduced new weekly rate limits. Under this revised system, Pro users are allocated 40 to 80 "hours" of Sonnet 4 usage per week. Max users on the $200 tier receive 240 to 480 "hours" of Sonnet 4, plus an additional 24 to 40 "hours" of the more advanced Opus 4. Nearly five months later, the widespread frustration among developers has shown no signs of abating.

The primary issue lies in the ambiguity of these "hours." They do not represent actual clock time but rather token-based limits that fluctuate significantly based on factors such as codebase size, conversation length, and the complexity of the code being processed. Independent analysis suggests that the actual per-session limits translate to approximately 44,000 tokens for Pro users and 220,000 tokens for the $200 Max plan.

"It’s confusing and vague," one developer articulated in a widely shared analysis. "When they say ’24-40 hours of Opus 4,’ that doesn’t really tell you anything useful about what you’re actually getting."

The backlash has been fervent across platforms like Reddit and various developer forums. Numerous users have reported hitting their daily limits within 30 minutes of dedicated coding. Others have canceled their subscriptions entirely, denouncing the new restrictions as "a joke" and "unusable for real work."

Anthropic has publicly defended these changes, asserting that the limits impact fewer than five percent of its users and are primarily aimed at individuals running Claude Code "continuously in the background, 24/7." However, the company has not clarified whether this five percent figure pertains to Max subscribers or all users, a distinction critical to understanding the true scope of the impact.

How Block Built a Free AI Coding Agent That Works Offline

Goose adopts a fundamentally different approach to addressing the challenges of AI-assisted coding. Developed by Block, the payments company led by Jack Dorsey, Goose is engineered as an "on-machine AI agent." Unlike Claude Code, which processes queries on Anthropic’s remote servers, Goose is designed to run entirely on a user’s local computer, utilizing open-source language models that users download and manage themselves.

The project’s documentation highlights its ambition to go "beyond code suggestions" by enabling the agent to "install, execute, edit, and test with any LLM." The phrase "any LLM" is a crucial differentiator, underscoring Goose’s model-agnostic design. Developers have the flexibility to connect Goose to Anthropic’s Claude models if they possess API access, or integrate with OpenAI’s GPT-5, Google’s Gemini, or leverage services like Groq or OpenRouter. Most importantly, Goose excels at running entirely locally using tools such as Ollama, which simplifies the process of downloading and executing open-source models directly on personal hardware.

The practical implications of this local setup are profound. It eliminates subscription fees, usage caps, and rate limits, while also alleviating concerns about sensitive code being transmitted to external servers. All interactions with the AI remain securely on the user’s machine. Sareen, during his demonstration, remarked, "I use Ollama all the time on planes—it’s a lot of fun!" This anecdote perfectly illustrates how local models liberate developers from the constraints of internet connectivity.

What Goose Can Do That Traditional Code Assistants Can’t

Goose functions as either a command-line tool or a desktop application, capable of autonomously executing complex development tasks. Its capabilities extend to building entire projects from the ground up, writing and executing code, debugging failures, orchestrating workflows across multiple files, and interacting with external APIs—all with minimal human intervention.

This advanced functionality relies on what the AI industry refers to as "tool calling" or "function calling." This mechanism allows a language model to request specific actions from external systems. When a user instructs Goose to create a new file, run a test suite, or check the status of a GitHub pull request, the agent doesn’t merely generate text describing the action; it actually executes these operations within the local environment.

The effectiveness of this capability is heavily dependent on the underlying language model. According to the Berkeley Function-Calling Leaderboard, which ranks models based on their ability to translate natural language into executable code and system commands, Claude 4 models from Anthropic currently demonstrate superior performance in tool calling. However, newer open-source models are rapidly closing this gap. Goose’s documentation specifically highlights several open-source options with strong tool-calling support, including Meta’s Llama series, Alibaba’s Qwen models, Google’s Gemma variants, and DeepSeek’s reasoning-focused architectures.

Furthermore, Goose integrates with the Model Context Protocol (MCP), an emerging standard for connecting AI agents to various external services. Through MCP, Goose can access databases, search engines, file systems, and third-party APIs, significantly expanding its operational capabilities beyond the inherent limits of the base language model.

Setting Up Goose with a Local Model

For developers seeking a completely free, privacy-preserving AI coding setup, the process involves three key components: Goose itself, Ollama (a tool for running open-source models locally), and a compatible language model.

Step 1: Install Ollama
Ollama is an open-source project designed to simplify the deployment of large language models on personal hardware. It automates the complex tasks of downloading, optimizing, and serving models through an intuitive interface. Users can download and install Ollama from ollama.com. Once installed, models can be pulled with a single command. For coding tasks, Qwen 2.5 is recommended for its strong tool-calling support:
ollama run qwen2.5
The chosen model will automatically download and begin running on the user’s machine.

Step 2: Install Goose
Goose is available as both a desktop application and a command-line interface (CLI). The desktop version offers a visual user experience, while the CLI caters to developers who prefer working exclusively in the terminal. Installation instructions vary by operating system but typically involve downloading pre-built binaries from Goose’s GitHub releases page or utilizing a package manager. Block provides binaries for macOS (Intel and Apple Silicon), Windows, and Linux.

Step 3: Configure the Connection
In Goose Desktop, users navigate to Settings, then Configure Provider, and select Ollama. They confirm that the API Host is set to http://localhost:11434 (Ollama’s default port) and click Submit. For the command-line version, users run goose configure, select "Configure Providers," choose Ollama, and enter the desired model name when prompted. With these steps completed, Goose is connected to a language model running entirely on the user’s hardware, ready to execute complex coding tasks without any subscription fees or external dependencies.

The RAM, Processing Power, and Trade-Offs You Should Know About

A natural question arises regarding the necessary computer hardware. Running large language models locally demands significantly more computational resources than typical software. The primary constraint is memory, specifically RAM on most systems, or VRAM if a dedicated graphics card is used for acceleration.

Block’s documentation suggests that 32 gigabytes of RAM provides "a solid baseline for larger models and outputs." For Mac users, the computer’s unified memory serves as the main bottleneck. For Windows and Linux users with discrete NVIDIA graphics cards, GPU memory (VRAM) becomes more critical for accelerating model inference.

However, getting started doesn’t necessarily require expensive, high-end hardware. Smaller models with fewer parameters can run effectively on more modest systems. Qwen 2.5, for example, is available in multiple sizes, with its smaller variants capable of operating efficiently on machines equipped with 16 gigabytes of RAM. "You don’t need to run the largest models to get excellent results," Sareen emphasized, recommending developers start with a smaller model to test their workflow and scale up as needed. For context, an entry-level Apple MacBook Air with 8 gigabytes of RAM would likely struggle with most capable coding models, whereas a MacBook Pro with 32 gigabytes—an increasingly common configuration among professional developers—can handle them comfortably.

Why Keeping Your Code Off the Cloud Matters More Than Ever

While Goose with a local LLM presents a compelling alternative, it is not a perfect, one-to-one substitute for Claude Code. Developers should be aware of the inherent trade-offs involved in this comparison.

Model Quality: Claude 4.5 Opus, Anthropic’s flagship model, arguably remains the most capable AI for complex software engineering tasks. It demonstrates superior ability in understanding intricate codebases, accurately following nuanced instructions, and generating high-quality code on the initial attempt. Although open-source models have made dramatic advancements, a discernible gap persists, particularly for the most challenging and abstract coding problems. One developer who transitioned to the $200 Claude Code plan starkly described the difference: "When I say ‘make this look modern,’ Opus knows what I mean. Other models give me Bootstrap circa 2015."

Context Window: Claude Sonnet 4.5, accessible via API, offers an exceptionally large one-million-token context window. This capacity is sufficient to load entire large codebases without the need for complex chunking or context management strategies. In contrast, most local models are typically limited to 4,096 or 8,192 tokens by default, although many can be configured for longer contexts at the expense of increased memory usage and slower processing speeds.

Speed: Cloud-based services like Claude Code operate on dedicated server hardware specifically optimized for AI inference, resulting in rapid processing. Local models, running on consumer-grade laptops, generally process requests more slowly. This difference in speed can significantly impact iterative workflows where developers are making rapid changes and awaiting immediate AI feedback.

Tooling Maturity: Claude Code benefits from Anthropic’s substantial engineering resources, leading to highly polished and well-documented features such as prompt caching (which can reduce costs by up to 90 percent for repeated contexts) and structured outputs. Goose, while actively developed with 102 releases to date, relies on community contributions and may exhibit less refinement in specific areas compared to its commercially backed counterparts.

How Goose Stacks Up Against Cursor, GitHub Copilot, and the Paid AI Coding Market

Goose enters an already crowded market of AI coding tools but carves out a distinctive niche.

Cursor, a popular AI-enhanced code editor, mirrors Claude Code’s premium pricing with a $20 per month Pro tier and a $200 Ultra tier. Cursor’s Ultra plan provides approximately 4,500 Sonnet 4 requests per month, a substantially different allocation model compared to Claude Code’s hourly resets. Projects like Cline and Roo Code, along with similar open-source initiatives, offer AI coding assistance but vary in their levels of autonomy and tool integration. Many of these tools primarily focus on code completion rather than the agentic task execution that defines both Goose and Claude Code.

Meanwhile, Amazon’s CodeWhisperer, GitHub Copilot, and various enterprise offerings from major cloud providers are primarily aimed at large organizations with complex procurement processes and dedicated budgets. These solutions are less relevant to individual developers and small teams seeking lightweight, flexible, and accessible tools.

Goose’s unique value proposition stems from its combination of genuine autonomy, model agnosticism, local operational capability, and zero cost. The tool does not aim to compete with commercial offerings solely on polish or raw model quality. Instead, its competitive edge lies in the freedom it provides—both financial and architectural—to developers.

The $200-a-Month Era for AI Coding Tools May Be Ending

The market for AI coding tools is evolving rapidly. Open-source models are improving at an astonishing pace, consistently narrowing the performance gap with proprietary alternatives. For instance, Moonshot AI’s Kimi K2 and z.ai’s GLM 4.5 now benchmark near Claude Sonnet 4 levels, and they are freely available.

If this trajectory continues, the quality advantage that currently justifies Claude Code’s premium pricing may erode significantly. Anthropic would then face increasing pressure to compete on features, user experience, and seamless integration rather than solely on raw model capability.

For the present, developers are presented with a clear choice. Those who demand the absolute best model quality, can afford premium pricing, and are willing to accept usage restrictions may continue to prefer Claude Code. However, those who prioritize cost, data privacy, offline access, and maximum flexibility now have a genuine and robust alternative in Goose. The very existence of a zero-dollar, open-source competitor offering comparable core functionality to a $200-per-month commercial product is remarkable. It highlights both the rapid maturation of open-source AI infrastructure and a strong appetite among developers for tools that genuinely respect their autonomy.

Goose is not without its limitations. It requires more technical setup than many commercial alternatives, and its effective use depends on hardware resources that not every developer possesses. Its model options, while improving swiftly, still trail the very best proprietary offerings for the most complex tasks. Yet, for a growing community of developers, these limitations are acceptable trade-offs for something increasingly rare in the AI landscape: a powerful tool that truly belongs to them.