Goose is a free, open-source AI agent from Block (the company behind Square, Cash App, and Afterpay) that runs entirely on your local machine. It has accumulated 29,400+ GitHub stars, 368 contributors, and 2,600+ forks since its January 2025 launch. Unlike cloud-dependent coding agents that charge $20 to $200 per month, Goose pairs with any LLM provider you choose, including fully local models through Ollama, meaning your code never has to leave your hardware. It connects to 3,000+ tools via MCP, supports reusable workflow recipes, and ships as both a CLI and desktop app.
That combination of zero cost, local execution, and open extensibility has positioned Goose as the most credible free alternative to commercial coding agents. Here is what it actually does, where it excels, and where you will hit friction.
What Goose Does (and Does Not Do)
Goose is not a code autocomplete tool. It is an autonomous agent that can scaffold projects, create and modify files, run tests, debug failures, execute shell commands, and iterate on results without constant human prompting. Think of it as a senior developer that takes your instruction, breaks it into steps, and executes each one while you watch.
The “on-machine” design is the key differentiator. Block built Goose as a financial technology company where data sensitivity is non-negotiable. Rather than routing code through cloud APIs, Goose operates directly on your system. When paired with a local LLM through Ollama or Docker Model Runner, the entire pipeline stays on your hardware: prompts, intermediate outputs, generated code, test results.
What Goose does not do is replace your IDE. It runs alongside your editor, executing tasks you delegate. It does not offer inline code suggestions, hover documentation, or the kind of real-time autocompletion you get from GitHub Copilot or Cursor. Goose handles multi-step workflows; your editor handles keystroke-level assistance.
The Architecture in 30 Seconds
Goose is built in Rust with a modular architecture: a core agent loop, a provider abstraction layer for LLMs, and an extension system built on the Model Context Protocol (MCP). When you give Goose a task, it plans a sequence of actions, selects the appropriate tools from its available extensions, executes them, evaluates results, and loops until the task is complete or it hits a blocker it cannot resolve.
The MCP layer means Goose does not need bespoke integrations for every tool. Any service that exposes an MCP server, and there are now over 3,000 of them, becomes available to Goose. GitHub, Jira, Slack, Google Drive, databases, monitoring dashboards: if it has an MCP server, Goose can talk to it.
Goose vs. Claude Code: Free Does Not Mean Inferior
The most common comparison is Goose versus Claude Code, Anthropic’s terminal-based coding agent. Claude Code requires a $20/month Pro or $200/month Max subscription. Goose costs nothing.
But the comparison is more nuanced than just price. According to a detailed comparison by TechBuddies, both tools can orchestrate end-to-end workflows: scaffolding, file manipulation, test execution, debugging. The differences emerge in three areas:
Model quality: Claude Code runs on Claude Opus/Sonnet with Anthropic’s internal optimizations for code tasks. Goose uses whatever model you configure. If you point it at Claude through the Anthropic API, you get comparable intelligence but pay per token. If you use a local model through Ollama, quality depends on the model you run. Llama 3 70B produces strong results; smaller models lose coherence on complex multi-file tasks.
Planning overhead: Goose’s planning-first approach generates detailed plans before execution. For large refactoring or multi-step builds, this is valuable. For quick single-file edits, it introduces latency that feels unnecessary. Claude Code is often faster for surgical changes.
Extensibility: This is where Goose wins outright. Claude Code has a fixed tool set. Goose connects to anything with an MCP server, and you can write custom extensions in minutes. If your workflow involves Jira tickets, Slack updates, and GitHub PRs, Goose can orchestrate all three in a single session.
Extensions and MCP: 3,000+ Tools, One Interface
Goose’s extension system is its strongest technical advantage. Extensions are MCP servers that give Goose access to external tools and data sources. The Goose documentation lists dozens of built-in extensions: GitHub for repository management, Jira for issue tracking, Google Drive for document access, PostgreSQL for database queries, and many more.
Adding an extension takes one command:
goose configure
# Select "Add Extension"
# Choose from the built-in list or point to a custom MCP server
The desktop app includes an Extensions Manager that makes discovery even simpler: browse available extensions, toggle them on or off, and configure credentials.
Writing a Custom Extension
If your team uses an internal tool that does not have an MCP server yet, building one is straightforward. MCP servers are lightweight HTTP services that follow a standardized protocol. Block provides templates in Python, TypeScript, and Rust. A minimal Python MCP server that exposes a single tool requires roughly 40 lines of code.
This matters because the extension ecosystem is growing fast. The MCP server registry crossed 3,000 entries in early 2026. Every new server immediately becomes available to Goose without any changes to Goose itself.
Recipes: Reusable Workflows as YAML
Extensions give Goose tools. Recipes tell it how to use them for specific workflows. A recipe is a YAML file that packages a goal, required extensions, structured inputs, and execution steps into a portable, shareable unit.
Here is a simplified example of a recipe that generates a weekly status report:
name: weekly-status
description: Generate weekly status report from project tools
extensions:
- github
- linear
- notion
instructions: |
1. Fetch all merged PRs from the last 7 days from GitHub
2. Pull completed tickets from Linear
3. Summarize key accomplishments and blockers
4. Write the report to a new Notion page titled "Week of {{date}}"
Every team member runs the same recipe and gets a consistent output. No more manually compiling updates from three different tools every Friday. One developer shared on Reddit that their team reduced weekly status meeting prep from 45 minutes to under 5 minutes per person using a Goose recipe.
Recipes also support sub-recipes for complex multi-stage workflows: a deployment recipe might call a testing sub-recipe, then a staging sub-recipe, then a release sub-recipe. This composability is closer to CI/CD pipeline design than traditional AI agent prompting.
Getting Started: From Install to First Task in 5 Minutes
Installation
CLI (macOS, Linux, Windows via Git Bash):
curl -fsSL https://github.com/block/goose/releases/download/stable/download_cli.sh | bash
macOS via Homebrew:
brew install block/tap/goose
Desktop app: Download the latest release from GitHub Releases for macOS, Windows, or Linux.
Configuration
On first run, Goose walks you through provider setup:
goose configure
# Select your LLM provider (Anthropic, OpenAI, Google, Ollama, etc.)
# Enter your API key (or point to a local Ollama instance)
# Choose your default model
Goose supports 25+ providers across three categories: API-based (Anthropic, OpenAI, Google Gemini, Mistral, xAI Grok), cloud platforms (AWS Bedrock, GCP Vertex, Azure OpenAI, Databricks), and local (Ollama, Docker Model Runner, Ramalama).
Running Your First Task
goose session
# Type: "Create a FastAPI project with a /health endpoint, SQLAlchemy models, and pytest tests"
Goose will plan the steps, create files, install dependencies, write tests, and run them. You watch in real-time and can interrupt or redirect at any point.
For fully local operation with zero cloud dependency:
# Install Ollama and pull a model
ollama pull llama3:70b
# Configure Goose to use Ollama
goose configure
# Select "Ollama" as provider, point to localhost:11434
Now everything stays on your machine. No API keys, no usage tracking, no rate limits.
Privacy and Compliance: Why the Local-First Model Matters
Block did not make Goose local-first as a novelty. As a financial technology company processing billions in transactions, Block needs tools where sensitive data never crosses network boundaries. Goose inherits that philosophy.
For European organizations operating under DSGVO (GDPR), this architecture directly addresses two common compliance headaches:
Data minimization: When using Goose with a local LLM, no prompts, code snippets, or agent outputs are transmitted to external servers. There is no data to minimize because it never leaves the machine.
Cross-border transfer: A fully local Goose setup eliminates questions about where your data is processed. It is processed on the machine sitting in your office, in your jurisdiction, on your hardware.
This does not mean Goose is automatically compliant with anything. You still need to evaluate how extensions connect to external services, and cloud LLM providers have their own data handling policies. But the option to run a fully air-gapped AI coding agent is genuinely unique among tools at this capability level.
Where Goose Falls Short
Goose is impressive, but pretending it has no weaknesses would be dishonest.
Model quality ceiling: If you run Goose with a local 7B-parameter model, results degrade noticeably on multi-file refactoring tasks. The agent is only as smart as the LLM behind it. Using top-tier cloud models (Claude Opus, GPT-4o) through APIs gives better results but adds cost that narrows the price advantage over Claude Code.
Planning latency: Goose’s plan-then-execute approach adds overhead for simple tasks. Asking it to rename a variable across a project takes longer than it should because Goose insists on generating a full execution plan first.
Documentation gaps: While improving, the documentation for writing custom extensions and advanced recipes could be more thorough. Community examples on GitHub Discussions are often the best resource.
No inline IDE integration: Goose runs in its own terminal or desktop window. If you want AI assistance inside VS Code or JetBrains, you need a different tool (or wait for the community to build an extension).
Hardware requirements for local LLMs: Running a 70B parameter model through Ollama requires 48GB+ RAM. Smaller models fit on more modest hardware but produce lower quality output. The “free” label assumes you already have capable hardware.
Frequently Asked Questions
Is Goose really free?
Yes. Goose is MIT-licensed open-source software with no subscription fees. If you use cloud LLM providers like the Anthropic or OpenAI APIs, you pay for API usage. For truly free operation, pair Goose with a local model through Ollama.
Can Goose replace Claude Code or GitHub Copilot?
Goose replaces Claude Code’s functionality (autonomous task execution, multi-step workflows) but not GitHub Copilot’s (inline code completion, hover docs). Goose handles project-level tasks; Copilot handles keystroke-level suggestions. Many developers use both.
What LLMs work with Goose?
Goose supports 25+ providers: Anthropic Claude, OpenAI GPT, Google Gemini, Mistral, xAI Grok, and local models through Ollama, Docker Model Runner, and Ramalama. You can switch models per session or configure defaults.
Does Goose send my code to the cloud?
Only if you configure a cloud LLM provider. When paired with a local model through Ollama, all processing stays on your machine. No prompts, code, or outputs leave your system.
What is the Agentic AI Foundation and how does Goose relate to it?
The Agentic AI Foundation (AAIF) is a Linux Foundation project launched in 2026 to standardize agent interoperability. Goose was contributed alongside Anthropic’s MCP and OpenAI’s AGENTS.md as founding projects. This means Goose’s development now has vendor-neutral governance.