Why Goose Might Be the Most Important Coding Agent You Haven't Tried

Goose has 51,000 GitHub stars and most developers still haven’t heard of it. That’s about to change.

While Claude Code and Cursor fight for the premium terminal agent market, Goose is doing something different: building an extensible agent framework in Rust that any LLM can plug into. It’s not a product — it’s a platform.

Architecture: why Rust matters

The architecture is the story here. Goose isn’t tied to a single model provider. You can run it with Claude, GPT-4, Gemini, or any local model through Ollama. The agent logic is separate from the model — which sounds obvious until you realize most coding agents are deeply coupled to their provider’s API.

Core components

��─────────────────────────────────────────────────────────────��
│                      Goose Core (Rust)                       │
│  ��──────────��  ��──────────��  ��──────────��  ��────────────��  │
│  │ Session  │  │  Tool    │  │  Config  │  │  Extension │  │
│  │ Manager  │  │ Registry │  │  Loader  │  │   Host     │  │
│  └──────────��  └──────────��  └──────────��  └────────────��  │
��─────────────────────────────────────────────────────────────��
        │              │              │              │
        ��              ��              ��              ��
��───────────────�� ��───────────�� ��─────────────�� ��─────────────��
│  Model Adapter │ │ MCP Client │ │ Plugin API  │ │  Built-in   │
│  (Claude/      │ │ (stdio/    │ │ (WASM/      │ │  Tools      │
│   OpenAI/      │ │  HTTP/     │ │  Native)    │ │ (read,      │
│   Ollama/      │ │  SSE)      │ │             │ │  write,     │
│   Custom)      │ │            │ │             │ │  exec, etc) │
��───────────────�� └───────────�� └─────────────�� └─────────────��

Session Manager: Handles conversation state, context compaction, and checkpoint/restore. Written in Rust for memory safety and performance.

Tool Registry: Dynamic tool discovery. Built-in tools (file ops, shell, grep, task) register at startup. Extensions add tools via the plugin API.

Extension Host: Sandboxed WASM runtime for plugins. Plugins cannot crash the core agent. Native plugins (dynamic libraries) available for performance-critical extensions.

MCP Client: Full MCP 2025-06-18 spec support. stdio, HTTP+SSE, and WebSocket transports. Works with any MCP server — filesystem, GitHub, Postgres, Kubernetes, browser automation, you name it.

Performance: the Rust advantage

Where Node.js-based agents sometimes lag on large codebases, Goose handles file operations and context management with noticeably less overhead.

For developers working on massive monorepos, this matters. The 51K stars aren’t hype — they’re developers who found something that works differently.

Installation and setup

Quick start (binary)

# macOS
brew install block/goose/goose

# Linux
curl -fsSL https://github.com/block/goose/releases/latest/download/goose-linux-x64.tar.gz | tar xz
sudo mv goose /usr/local/bin/

# Windows (PowerShell)
irm https://github.com/block/goose/releases/latest/download/goose-windows-x64.zip | tar xz
# Add to PATH

From source (Rust toolchain required)

git clone https://github.com/block/goose.git
cd goose
cargo install --path . --locked

Verify installation

goose --version
# goose 1.0.12 (rustc 1.82.0)

Configuration: models and providers

Goose uses a TOML config at ~/.config/goose/config.toml (Linux/macOS) or %APPDATA%\goose\config.toml (Windows).

Basic configuration

[model]
provider = "anthropic"
model = "claude-3-5-sonnet-20241022"
api_key = "${ANTHROPIC_API_KEY}"

[session]
auto_compact = true
compact_threshold = 0.8  # Compact at 80% context window

[tools]
builtin = ["read", "write", "edit", "glob", "grep", "task", "shell"]

Multi-model setup (recommended)

[models.default]
provider = "anthropic"
model = "claude-3-5-sonnet-20241022"

[models.coding]
provider = "anthropic"
model = "claude-3-5-opus-20241022"

[models.fast]
provider = "openai"
model = "gpt-4o-mini"

[models.local]
provider = "ollama"
model = "qwen2.5-coder:32b"
base_url = "http://localhost:11434"

[profiles]
default = "default"
deep-work = "coding"
quick-edits = "fast"
offline = "local"

Switch profiles at runtime:

goose --profile deep-work "Refactor the auth module"
goose --profile quick-edits "Fix typo in README"
goose --profile offline "Explain this function"  # No API calls

Environment variable API keys (security best practice)

# ~/.bashrc or ~/.zshrc
export ANTHROPIC_API_KEY="sk-ant-..."
export OPENAI_API_KEY="sk-..."
export GOOGLE_API_KEY="..."
# Goose reads ${VAR} syntax from config.toml

MCP integration: the extensibility killer feature

MCP (Model Context Protocol) is where Goose shines. Any MCP server becomes a tool set instantly.

Popular MCP servers for coding

Adding MCP servers to Goose

# ~/.config/goose/config.toml
[mcp.servers.filesystem]
command = "npx"
args = ["-y", "@modelcontextprotocol/server-filesystem", "/home/user/myproject"]
env = {}

[mcp.servers.github]
command = "npx"
args = ["-y", "@modelcontextprotocol/server-github"]
env = { GITHUB_TOKEN = "${GITHUB_TOKEN}" }

[mcp.servers.postgres]
command = "npx"
args = ["-y", "@modelcontextprotocol/server-postgres"]
env = { DATABASE_URL = "${DATABASE_URL}" }

Restart Goose and the tools appear automatically:

goose> /tools
Available tools:
  read, write, edit, glob, grep, task, shell (builtin)
  fs_read, fs_write, fs_list (filesystem MCP)
  gh_pr_list, gh_issue_create, gh_repo_get (github MCP)
  sql_query, sql_execute (postgres MCP)

Real example: database-driven development

goose --profile coding "
I need to add a 'last_login_at' column to the users table.
1. Check current schema
2. Generate migration
3. Update the User model in src/models/user.ts
4. Add index for the new column
5. Run tests to verify
"

Goose will:

1. Call sql_query to inspect information_schema.columns
2. Write a migration file via fs_write
3. Edit the TypeScript model via edit
4. Run the migration via shell
5. Execute test suite via task

All without you leaving the terminal.

Plugin system: extend without forking

Goose’s plugin API (WASM-based) lets you add custom tools, model adapters, and workflow hooks.

Installing plugins

# From Goose registry
goose extension install github.com/block/goose-lsp
goose extension install github.com/block/goose-docker

# From local path (development)
goose extension install ./my-custom-extension

Building a custom tool (Rust)

// my-tool/src/lib.rs
use goose_plugin::{Tool, ToolSpec, Parameter};

#[no_mangle]
pub extern "C" fn goose_plugin_init() -> ToolSpec {
    ToolSpec {
        name: "terraform_plan",
        description: "Run terraform plan and parse output",
        parameters: vec![
            Parameter::string("working_dir", "Directory with terraform files"),
            Parameter::bool("json_output", "Output as JSON"),
        ],
        handler: |args| {
            let dir = args.get("working_dir").unwrap();
            let output = std::process::Command::new("terraform")
                .args(["plan", "-out=tfplan"])
                .current_dir(dir)
                .output()?;
            Ok(serde_json::json!({ "stdout": String::from_utf8_lossy(&output.stdout) }))
        },
    }
}

Compile to WASM:

cargo build --target wasm32-wasip1 --release
goose extension install ./target/wasm32-wasip1/release/my_tool.wasm

Now available in every session:

goose> terraform_plan --working_dir ./infra --json_output true

Native plugins (dynamic libraries) for performance

For tools needing heavy computation (AST parsing, type checking), native plugins avoid WASM overhead:

# ~/.config/goose/config.toml
[extensions.native]
goose_typescript = { path = "/usr/local/lib/goose_typescript.so" }
goose_rust_analyzer = { path = "/usr/local/lib/goose_rust_analyzer.so" }

Real-world workflows

Workflow 1: Feature branch to PR (fully automated)

goose --profile coding "
Create a feature branch for 'add-export-csv'.
Implement CSV export for the orders page:
1. Add 'export-csv' endpoint to src/api/orders.ts
2. Add 'Download CSV' button to src/components/OrdersTable.tsx
3. Write unit tests for the export logic
4. Create PR with description linking to JIRA ticket EXP-2341
"

Goose executes across multiple files, runs tests, commits, pushes, and opens PR via GitHub MCP.

Workflow 2: Legacy codebase modernization

goose --profile deep-work "
Modernize the payment module:
1. Scan src/payments/ for deprecated Stripe API usage
2. Upgrade to Stripe 2024-06-20 API (PaymentIntents v2)
3. Update TypeScript types to strict mode
4. Add idempotency keys to all mutating operations
5. Generate integration tests using testcontainers
6. Run full test suite and fix failures
"

The Rust performance shines here — scanning 50K LOC takes seconds, not minutes.

Workflow 3: Local-only development (privacy/air-gapped)

# Start Ollama with local model
ollama serve &
ollama pull qwen2.5-coder:32b

# Use Goose with zero external calls
goose --profile offline "
Refactor the user authentication flow to use JWT refresh tokens.
Keep all changes local. No telemetry. No API calls.
"

Perfect for regulated environments, proprietary codebases, or offline work.

Workflow 4: Multi-repo coordination

goose --profile coding "
We're upgrading the shared 'api-client' package from v2 to v3 across 5 repos:
1. Clone all 5 repos (list in REPOS.md)
2. Update package.json dependency
3. Fix breaking changes in each codebase
4. Run tests in each repo
5. Create coordinated PRs with linked issue
"

Goose’s session persistence and task tool handle multi-repo workflows that would crash single-repo agents.

Comparison: where Goose wins (and loses)

Choose Goose when:

• You need model provider freedom (avoid vendor lock-in)
• Local/offline development is required
• You’re building custom tooling on top of an agent
• Working on massive monorepos where performance matters
• You want MCP as a first-class citizen

Stick with Claude Code/Cursor when:

• You want polished VS Code integration out of the box
• Team collaboration features (shared sessions, billing) matter
• You prefer a managed product over a platform to customize
• Your team isn’t comfortable with terminal-first workflows

Advanced: Goose as a library (embedding in your tools)

Goose isn’t just a CLI — the core is a Rust library you can embed.

// Your custom AI-powered code review bot
use goose_core::{Session, ModelAdapter, ToolRegistry};

let mut session = Session::new()
    .with_model(ModelAdapter::anthropic("claude-3-5-sonnet"))
    .with_tools(ToolRegistry::default()
        .add(github_mcp_tools())
        .add(lsp_tools())
    );

let review = session.run("
Review PR #2341 for security issues.
Focus on: auth bypass, SQL injection, XSS.
Comment inline with severity.
").await?;

github_api.create_review_comment(pr_number, review).await?;

This is how companies build internal developer platforms on Goose.

Getting help and contributing

• Documentation: https://block.github.io/goose/
• Discord: https://discord.gg/goose (active community, ~8K members)
• GitHub: https://github.com/block/goose (issues, discussions, PRs welcome)
• Plugin registry: https://github.com/block/goose-extensions

The bottom line

Goose is the most extensible coding agent in 2026. Its Rust core, model-agnostic architecture, first-class MCP support, and WASM/native plugin system make it a platform — not just a tool.

The trade-off: you assemble your own experience. No hand-holding, no polished IDE integration, no managed team dashboard. For developers who want full control over their agent stack — choosing the model, the tools, the extensions, the workflows — Goose is worth serious consideration.

The 51K stars aren’t hype. They’re developers who found something that works differently.

Related articles

• Coding Agents in 2026: Three Hard Lessons HN Developers Learned the Expensive Way
• What Developers Think About Coding Agents — The Skill Atrophy Crisis, Interface Wars, and Trust Divide From 500 HN Comments
• Model Musical Chairs: What 500 Hacker News Comments Reveal About the Death of AI Model Loyalty
• What Developers Really Say About Claude Code — Honest Community Verdict

Built by Y Combinator alumni, aiFiesta gives you every major AI model in one chat for $12/mo. Compare answers side-by-side and pick the best one for your task.

• Model Musical Chairs: What 500 Hacker News Comments Reveal About the Death of AI Model Loyalty

Built by Y Combinator alumni, aiFiesta gives you every major AI model in one chat for $12/mo. Compare answers side-by-side and pick the best one for your task.