What Is Goose AI Agent? Block’s Open-Source Contribution Explained

Goose is an open-source AI coding agent originally created at Block (the parent company of Square and Cash App) and donated to the Linux Foundation’s Agentic AI Foundation in 2026. It’s a terminal-first agent that can read and write files, execute shell commands, search the web, and integrate with external services via MCP — all driven by natural language instructions. The Apache 2.0 license is a meaningful differentiator: unlike Claude Code’s proprietary terms or n8n’s AGPLv3 requirements, Apache 2.0 allows commercial use, modification, and embedding without source disclosure obligations. This makes Goose viable for companies building their own internal tooling on top of the agent framework. The provider flexibility is the other key differentiator: Goose supports Anthropic, OpenAI, Google Gemini, Groq, Mistral, Cohere, and Ollama among 15+ providers, configurable per-session. A developer can use Claude Opus 4.7 for complex reasoning tasks and switch to a local Qwen3 model for simple code generation — all within the same agent framework without tool switching. This flexibility, combined with the desktop app available on all major platforms, positions Goose as a general-purpose agent runtime rather than a tool tied to a specific LLM vendor.

Key Features: MCP Extensions, Multi-Provider Support, and Local Mode

MCP ecosystem is Goose’s strongest technical capability. The 70+ available MCP extensions connect Goose to databases, APIs, project management tools, communication platforms, and development infrastructure. When an extension provides MCP tools, Goose can call them as part of autonomous task execution — fetching Jira tickets, querying databases, posting to Slack, or running CI/CD workflows.

Multi-provider support means developers aren’t locked to a single LLM. Provider switching is configured in Goose’s settings file:

# ~/.config/goose/providers.yaml
default_provider: anthropic
providers:
  anthropic:
    model: claude-opus-4-7-20261101
  openai:
    model: gpt-5.5
  ollama:
    model: qwen3-coder:32b
    base_url: http://localhost:11434

Local mode via Ollama enables zero-API-cost operation. Running Goose with a local Qwen3 Coder or DeepSeek Coder model on appropriate hardware costs nothing beyond electricity. For privacy-sensitive codebases or teams with compliance requirements prohibiting external API calls, local mode makes Goose viable where cloud-only agents cannot operate.

Desktop app provides a GUI for users who prefer not to work in terminal, while maintaining the same agent capabilities. The GUI is useful for session management — viewing history, switching providers, and managing extension configuration.

Installation and Getting Started in 5 Minutes

# macOS (Homebrew)
brew install block/tap/goose

# Linux
curl -fsSL https://getgoose.ai/install.sh | bash

# Configure your first provider
goose configure

# Start a session
goose session

After installation, goose configure prompts for your preferred LLM provider and API key. For local-only usage with Ollama, no API key is needed:

# Configure for local Ollama
goose configure --provider ollama --model qwen3-coder:32b

# Verify Ollama is running
ollama serve  # in another terminal

# Start session
goose session

Once in a session, Goose accepts natural language task descriptions: “review the authentication module for security issues and generate a list of findings” or “add comprehensive error handling to all database calls in the user service.” Goose reads relevant files, executes shell commands as needed, and produces output or file changes based on the task.

MCP Ecosystem: 70+ Extensions for Real Workflow Power

The MCP extension catalog is where Goose’s practical capabilities expand beyond basic file operations. Notable categories:

Development infrastructure: GitHub, GitLab, Jira, Linear — Goose can read issues, create PRs, and comment on tickets as part of automated workflows.

Databases: PostgreSQL, MySQL, SQLite — Goose can query databases directly, making it useful for data exploration and schema analysis tasks without separate database tooling.

Communication: Slack, email — Goose can send notifications and messages as part of workflow completion.

Web: Search, scraping — Goose can research documentation, find library examples, and gather context from the web.

Installing extensions adds them to the available tool set for the current session or globally:

# Install the GitHub MCP extension
goose extension add github --token YOUR_GITHUB_TOKEN

# Install database extension
goose extension add postgres --connection-string postgresql://user:pass@localhost/db

The MCP architecture means any new MCP server can be integrated — the 70+ officially supported extensions are a baseline, not a ceiling.

Running Goose with Local Models for Zero API Cost

Goose’s Ollama integration is production-quality for code-focused tasks. Best local models for coding agents in 2026:

For teams with hardware constraints, the 7B models are capable enough for routine code generation and review. For complex reasoning tasks, 32B models at Q4 quantization deliver meaningfully better results on code that requires understanding of multi-file dependencies.

The privacy advantage: all code, context, and conversation history stays on-premise. For healthcare organizations, financial services firms, or government agencies where code cannot leave controlled infrastructure, local Goose is often the only viable AI coding agent option.

Goose vs Claude Code vs Aider vs Cline: Honest Comparison

Claude Code leads on benchmark performance — the 80.9% SWE-bench score with Anthropic’s tooling optimizations is the current ceiling for autonomous coding agents. Aider has excellent git-native workflow integration and strong commit message generation. Cline’s VS Code integration makes it the smoothest experience for developers who don’t want to leave the IDE. Goose wins on three dimensions: provider flexibility (switch models without switching tools), MCP ecosystem breadth, and Apache 2.0 licensing for commercial embedding.

Real-World Use Cases and Developer Workflows

Code review automation: Goose reviews entire pull requests when given a GitHub MCP extension and PR URL. “Review this PR for security issues, performance problems, and adherence to our coding standards” triggers a multi-file analysis with specific findings.

Database exploration: Combined with a database MCP extension, Goose can answer “which tables have no foreign key constraints?” or “show me all queries that don’t use parameterized input” by querying the schema and analyzing query patterns.

Documentation generation: Goose reads a codebase and generates or updates documentation: “generate JSDoc comments for all exported functions in the src/ directory that currently lack them.”

Local private agent: For teams processing sensitive data, running Goose with Ollama on on-premise hardware creates a fully air-gapped AI coding assistant. No external API calls, no data leaving the network.

Who Should Use Goose in 2026?

Goose fits a specific developer profile: teams that need to switch between AI providers without switching tools, organizations with data sovereignty requirements that necessitate on-premise local model deployment, and companies building internal AI agent tooling under a permissive license. With 15+ supported providers and no vendor lock-in, Goose is the right choice when the LLM landscape is changing faster than you want to renegotiate tool dependencies. The Apache 2.0 license matters for teams embedding AI agent capabilities into commercial products — no AGPLv3 source disclosure, no proprietary restrictions.

Use Goose if: You need provider flexibility to switch between LLM models without changing tools. Your team has compliance requirements that prevent external API calls (local Ollama mode). You want to build internal tooling on top of an AI agent framework under Apache 2.0. The MCP ecosystem covers your required integrations.

Skip Goose if: Maximum SWE-bench performance matters (use Claude Code). You want the tightest git workflow integration (Aider). You primarily work in VS Code and want IDE integration (Cline). You’re not comfortable with CLI-first tooling.

FAQ

What is Goose AI agent and who made it?

Goose is an open-source AI coding agent originally created at Block (parent company of Square and Cash App) and donated to the Linux Foundation’s Agentic AI Foundation in 2026. Built in Rust, it’s Apache 2.0 licensed and supports 15+ AI providers including local Ollama models. It runs on macOS, Linux, and Windows with both CLI and desktop GUI interfaces.

Does Goose work without internet access?

Yes. Configure Goose with an Ollama provider and a locally-hosted model (Qwen3 Coder, DeepSeek Coder, etc.) to operate completely offline. No API keys required, no external network calls. The Ollama server runs locally; Goose connects to it via localhost. Suitable for air-gapped environments and privacy-sensitive codebases.

How does Goose compare to Claude Code?

Claude Code scores 80.9% on SWE-bench Verified and has the deepest Anthropic tooling integration. Goose supports 15+ providers, 70+ MCP extensions, Apache 2.0 licensing, and local model support — making it more flexible but with lower peak performance. Teams needing maximum coding capability choose Claude Code; teams needing provider flexibility, local mode, or commercial embedding choose Goose.

What are MCP extensions in Goose?

MCP (Model Context Protocol) extensions are integrations that give Goose access to external tools and services — GitHub, databases, Slack, Jira, and 70+ others. Extensions provide MCP tools that Goose can call as part of autonomous task execution. Any MCP-compatible server can be added, making the 70 official extensions a baseline rather than a hard limit.

Is Goose free to use commercially?

Yes. The Apache 2.0 license allows commercial use, modification, and embedding without restrictions or source disclosure requirements. You can build internal tools on top of Goose, include it in commercial products, or deploy it in enterprise environments without licensing fees or obligations to open-source your modifications.