Goose by Block: The Free, Open-Source AI Agent with 29K GitHub Stars

Block — the company behind Square, Cash App, and Afterpay — has quietly built one of the most serious open-source AI agents on the market. Goose isn't a code autocomplete extension. It's a fully autonomous agent that installs packages, edits files, executes shell commands, runs tests, and reads the results — the entire dev loop, automated.

With 29,000+ GitHub stars, Apache 2.0 licensing, support for 15+ LLM providers, and now under the stewardship of the Linux Foundation's Agentic AI Foundation (AAIF), Goose is becoming increasingly hard to ignore. Especially when tools like Claude Code cost up to $200/month and Goose costs exactly $0 in subscription fees.

In this review, we break down what Goose actually does well, where it falls short, how it compares to Claude Code, and how to set it up in under 10 minutes.

What Is Goose?

Goose is a local, extensible, open-source AI agent designed to automate complex engineering tasks end-to-end. It runs on your machine — not in the cloud — and orchestrates language models to execute real system-level actions.

Unlike GitHub Copilot or Cursor (which complete code inline in your editor), Goose operates at the shell level. It can:

• Scaffold entire projects from scratch
• Install dependencies and configure environments
• Read, write, and refactor files across your codebase
• Execute shell commands and interpret their output
• Run tests, catch failures, and iterate automatically
• Call external APIs and services
• Orchestrate multi-step workflows with minimal human intervention

The core behavior is driven by "tool calling" — a pattern where the language model can invoke specific tools exposed by the host environment. When you ask Goose to "create a new API route, update the tests, and run the test suite," it doesn't just describe how to do it. It calls commands that write files, edits code, runs the test runner, and inspects the output.

Key specs:

• License: Apache 2.0
• Language: Rust core + TypeScript/Electron desktop
• GitHub stars: 29,000+
• Contributors: 350+
• LLM providers supported: 25+ (Anthropic, OpenAI, Google, Ollama, Mistral, xAI Grok, Azure, Bedrock, OpenRouter, and more)
• MCP extensions: 70+ documented, 3,000+ available via MCP ecosystem
• Platforms: macOS, Linux, Windows

The Linux Foundation Stamp of Approval

In December 2025, the Linux Foundation announced the formation of the Agentic AI Foundation (AAIF) — with Goose as one of three inaugural projects alongside Anthropic's Model Context Protocol (MCP) and OpenAI's AGENTS.md.

This is a significant signal. The AAIF is backed by Anthropic, OpenAI, Block, and other major players. For enterprise buyers evaluating open-source AI agent frameworks, being part of the Linux Foundation umbrella provides:

• Long-term governance and maintenance commitments
• A vendor-neutral roadmap
• Community-driven security audits
• Alignment with open standards (MCP)

The practical effect: Goose is no longer just "Block's side project." It's infrastructure-grade open-source software.

Core Features Deep Dive

1. Model Agnosticism — The Killer Feature

Goose's most important feature is that it is genuinely model-agnostic. You can configure it to use:

The ability to swap models mid-project is practical — not just theoretical. Teams can run Claude Opus 4.6 for complex reasoning tasks and route simpler tasks to a local Llama 4 model to reduce API costs.

2. MCP Extensions — 3,000+ Tools Out of the Box

Goose was one of the earliest adopters of the Model Context Protocol, and it shows. The Extensions Manager (built into the desktop app) lets you browse, enable, and configure extensions with a single toggle:

• GitHub — create PRs, review code, manage issues
• Google Drive — read and write documents
• Databases — PostgreSQL, SQLite, MongoDB connectors
• Browser — web scraping and Playwright automation
• Docker — manage containers and compose files
• File systems — structured file access with permission controls
• Custom MCP servers — point Goose at any local or remote MCP server

Beyond the 70+ documented first-party extensions, Goose can connect to any of the 3,000+ community-built MCP servers in the ecosystem. If a tool has an MCP server, Goose can use it.

3. Recipes — Reusable Workflow Automation

Recipes are one of Goose's most underrated features. A Recipe is a YAML file that packages:

• A prompt or set of instructions
• Required extensions
• Input parameters
• Retry logic and error handling

# Example Recipe: Run a full test suite and file a GitHub issue on failure
version: 1.0
name: test-and-report
description: Run pytest and create a GitHub issue if tests fail
extensions:
  - github
parameters:
  - name: repo
    type: string
    description: GitHub repo in owner/repo format
steps:
  - action: shell
    command: pytest --tb=short
    on_failure:
      - action: github.create_issue
        title: "Test failure on {{ date }}"
        body: "{{ step.output }}"
        repo: "{{ params.repo }}"

Recipes are shareable and composable. The Goose community has published recipes for common patterns like "set up a new Node.js project," "migrate a database schema," and "generate and commit a changelog."

4. Subagent Parallelism

Goose can spawn independent subagents to handle tasks in parallel — code review in one lane, documentation in another, file processing in a third — while keeping the main conversation clean. This is a capability that most competing tools (including Claude Code) are still developing.

Goose vs. Claude Code: Honest Comparison

The honest take: Claude Code is easier to set up and has tighter IDE integration out of the box. But Goose is more capable on paper — and in practice for teams that configure it properly. The 7.7 vs. 5.3 AgentScore gap is notable.

Claude Code makes sense if you're already on Anthropic's subscription and want zero-friction setup. Goose makes sense if you care about cost, data privacy, model flexibility, or long-term vendor independence.

Setting Up Goose in 10 Minutes

Option A: Desktop App (Recommended for Most Users)

1. Download the installer from goose-docs.ai for your platform (macOS, Windows, Linux)
2. Open the app — on first launch, you'll see the provider setup wizard
3. Select your provider (Anthropic, OpenAI, Google, or Ollama for local)
4. Enter your API key
5. Choose your default model

That's it. Goose is ready to use.

Option B: CLI + Ollama (Fully Local, Zero Cost)

For a fully local setup with no API costs:

# Install Ollama first
curl -fsSL https://ollama.com/install.sh | sh

# Pull a capable model
ollama pull llama4:scout   # 17B vision-language model, fits on 24GB VRAM

# Install Goose CLI
curl -fsSL https://github.com/block/goose/releases/latest/download/goose-installer.sh | sh

# Configure Goose to use Ollama
goose configure
# Select: Ollama
# Select model: llama4:scout
# No API key required

# Start your first session
goose session start

Option C: JetBrains Plugin

Since January 2026, the ACP registry lets JetBrains users install Goose with one click inside IntelliJ, PyCharm, or WebStorm — no separate subscription required. Go to Settings → Plugins → Marketplace and search for "Goose."

Security: What You Need to Know

Security is the most important thing to understand before deploying Goose in a production-adjacent environment.

In January 2026, Block published a detailed post-mortem of an internal red team exercise called "Operation Pale Fire" — in which Block's security team successfully compromised Goose through a combination of phishing and prompt injection.

What happened: The red team crafted a poisoned Recipe with malicious instructions hidden in invisible Unicode characters, disguised as debugging help. The recipe tricked both the developer and the AI agent into downloading and running an infostealer.

What Block fixed:

• Recipe visualization — users now see exactly what a recipe does before running it
• Unicode character stripping — hidden instructions can't be embedded in recipes
• Improved permission confirmations for destructive operations
• MCP server malware checking
• Adversarial AI monitoring — a second AI monitors Goose's actions for malicious patterns

Practical security guidance for Goose users:

• Treat Goose as you would any script running with your credentials
• Run it in a sandboxed dev environment for untrusted tasks
• Use permission-gated MCP extensions rather than shell-level access where possible
• Review external recipes for hidden Unicode characters before execution

Real-World Performance: What Testers Found

Independent testing conducted on a Next.js 15 SaaS application and a Python FastAPI service (March–April 2026) found:

• Claude Opus 4.6 via Goose produced the most accurate multi-step results across complex refactoring tasks
• GPT-4o via Goose was stronger at following precise formatting requirements
• Llama 4 via Ollama had a ~20% higher error rate on complex tool chains but was fully private and cost-free
• Goose's Recipe system saved an estimated 40–60 minutes per week on repetitive tasks like changelog generation, dependency audits, and PR description writing

The Berkeley Function-Calling Leaderboard confirms that Claude 4-series models currently lead on tool-calling accuracy — which means pairing Goose with Anthropic's models gives you the best of both worlds: open-source infrastructure with frontier model performance.

Pros and Cons

Who Should Use Goose?

Goose is the right choice if you:

• Want a fully autonomous AI agent without a $200/month subscription
• Need model flexibility — switching between Anthropic, OpenAI, Google, or local models
• Work in regulated environments where code cannot leave your infrastructure (Ollama setup)
• Want to build reusable automation workflows (Recipes) for your team
• Value open-source governance and long-term vendor independence
• Are a senior developer comfortable with terminals and configuration files

Stick with Claude Code if you:

• Want the easiest possible setup with minimal configuration
• Are already on an Anthropic subscription and don't need model flexibility
• Primarily work within VS Code with tight editor integration
• Prefer a single-vendor relationship with enterprise support

Key Takeaways

1. Goose is free — Apache 2.0, no subscription, pay only for API usage (or nothing with Ollama)
2. 29,000+ GitHub stars and Linux Foundation backing signal genuine enterprise momentum
3. Model-agnostic design is Goose's strongest architectural advantage — you can run any frontier model or fully local models
4. 3,000+ MCP tools make Goose one of the most extensible AI agents available
5. Recipes are an underrated feature — reusable YAML workflows that save significant time
6. Security requires care — Block has done the work of proactive red-teaming, but auto-approve mode should never be used in critical environments
7. AgentScore 7.7/10 vs. Claude Code's 5.3/10 — Goose outperforms on the metrics that matter for autonomous task execution

Frequently Asked Questions

Is Goose completely free? Yes — Goose itself is free and open source (Apache 2.0). You only pay for the LLM you connect it to. If you use Ollama with a local model, the entire stack is free with zero data leaving your machine.

Does Goose work without internet? Yes, with Ollama. Run a local model like Llama 4 Scout or Qwen3, and Goose operates entirely offline. This is ideal for air-gapped environments or high-security contexts.

Can I use Goose at work without worrying about data leaks? If you configure Goose with Ollama and a local model, nothing leaves your machine. For cloud providers (Anthropic, OpenAI, etc.), your prompts go through their APIs under their standard data handling policies. Read your provider's enterprise data agreement before use.

Is Goose better than Claude Code? By AgentScore metrics (7.7 vs. 5.3), yes. By setup simplicity and IDE polish, Claude Code wins. The best answer is: if you want model flexibility and zero subscription cost, Goose wins. If you want the fastest path to a working setup, Claude Code wins.

How do I install Goose extensions? Open the Goose desktop app, go to Settings → Extensions, browse the extension catalog, and toggle on what you need. Each extension has a configuration panel for credentials and settings.

What happens if Goose makes a mistake? Goose will confirm before taking destructive actions (deleting files, force-pushing, etc.) unless you've enabled auto-approve. Always run Goose in a dev environment with version control so you can roll back any unintended changes.

Goose is under active development. Features and star counts referenced in this article reflect April 2026 data. Check goose-docs.ai and the block/goose GitHub repository for the latest releases.