Goose: The Open Source AI Agent With 70+ MCP Extensions

Why Goose Is Trending Right Now

Goose hit GitHub's daily trending list this week with over 47,000 stars behind it - a number that puts it alongside well-established infrastructure projects. The star velocity is not the interesting part though. What keeps pulling developers in is the combination: a general-purpose AI agent that runs natively on your machine, across three interfaces (desktop app, CLI, API), against 15+ LLM providers, and extensible through over 70 MCP integrations. That is a wider surface than most AI coding tools ship with. The project now lives under the Agentic AI Foundation (AAIF) at the Linux Foundation with an Apache 2.0 license - a governance move that signals long-term stability and open contribution, not a startup pivot.

What Goose Does

The project describes itself as "your native open source AI agent - desktop app, CLI, and API - for code, workflows, and everything in between." The framing is intentional: Goose is not a coding assistant bolted to a specific editor. It is a general-purpose agent designed to handle research, writing, automation, data analysis, and code work equally.

The core is built in Rust (64% of the codebase) with TypeScript handling the frontend layer (29%). The Rust foundation gives it real performance and portability without asking you to install a language runtime. Native apps ship for macOS, Linux, and Windows.

Where Goose separates itself from single-purpose tools is its extension model. It supports over 70 extensions through the Model Context Protocol (MCP), the same protocol that Claude Code, Cursor, and other AI tools use to connect external tools into an agent session. Databases, APIs, browser automation, file system tools - anything you have already wired up as an MCP server can drop into a Goose session without changes.

LLM support is broad: Anthropic (Claude), OpenAI, Google, Ollama for local models, OpenRouter, Azure, and AWS Bedrock are all supported. If you already have a Claude or ChatGPT subscription, Goose can use it through its ACP integration. You pick the provider, Goose handles the rest - the extension catalog and session behavior stay consistent regardless of which model is running underneath.

The agent goes beyond suggesting what to do. It installs packages, executes commands, edits files, runs tests, and loops until a task is done - the full lifecycle, not just the diff.

Installing and Trying It

The CLI is the fastest way in:

curl -fsSL https://github.com/aaif-goose/goose/releases/download/stable/download_cli.sh | bash

Run that, follow the prompts to configure an LLM provider, and you are running. The script handles dependencies on macOS and Linux. Windows users should grab the desktop app from the project's documentation site (linked in the References section).

The desktop app and CLI share the same configuration and extension catalog. You can use whichever fits your current task without managing separate setups.

To add an MCP extension once you are running:

goose extension add <extension-name>

The catalog covers databases, developer tooling, browser control, and third-party APIs. If you want to build a custom extension, it follows the standard MCP server pattern - a JSON schema describing the tools the server exposes, and a process that speaks the MCP wire protocol.

For a first task, try asking Goose to read a project directory, summarize the structure, and produce a markdown overview. That exercises the file system tools and the LLM connection without requiring any extension setup beyond the defaults.

Who Should Use It

Goose fits developers who want a general-purpose automation layer that is not tied to a specific editor or provider. If you already use Claude Code or Cursor inside your editor, Goose is not a replacement - it is a complement. Use it for the jobs that fall outside the editor context: batch processing files, building research pipelines, running data extraction across a set of URLs, or orchestrating a multi-step task while you work on something else in parallel.

Terminal-first developers will find the CLI mode well-suited to scripting Goose as a step in a larger workflow. The API surface means you can call it programmatically without needing the interactive session, which matters when you are building pipelines rather than chatting.

For teams evaluating open-source agent infrastructure, the provider-agnostic design is the headline advantage. Switching from OpenAI to Anthropic - or running local models through Ollama when API costs are a concern - does not require rewiring your extension catalog or rewriting your prompts. The same task runs the same way against a different model.

The Apache 2.0 license removes the licensing friction that complicates deployment with some commercial-adjacent open-source projects. You can modify it, self-host it, and build on top of it without negotiating terms.

How This Connects to the DevDigest Ecosystem

The reason Goose keeps surfacing in DevDigest content is MCP. If you have been tracking the MCP server landscape on mcp.developersdigest.tech, you already know that MCP is becoming the connective tissue for AI tooling in 2026. Goose's 70+ MCP extensions mean that any server you have configured for Claude Code - a database connector, a documentation fetcher, a custom internal API - can drop into a Goose session with no changes on the server side.

This also maps directly to the skills model at skills.developersdigest.tech. Goose extensions follow the same compositional logic: small, single-purpose tools that an agent assembles at runtime into multi-step workflows. A Goose extension that reads from a Postgres database and writes summaries to disk is structurally the same as a Claude Code skill that runs a QA pass and updates a markdown file. The mental model transfers.

The broader pattern emerging here is that MCP is becoming the lingua franca for agent extensibility. Skills, hooks, and MCP servers you build today work across a growing family of runtimes - Claude Code, Cursor, Goose, and whatever ships next. The investment pays dividends across tools rather than just one.

If you are building agent workflows and want a local runtime that is not Anthropic-specific, Goose is currently the most capable open-source option in that space.

Honest Assessment

Goose is genuinely useful for general-purpose automation work. The MCP integration is functional - if your MCP servers are working, they plug in. The multi-provider LLM support is a real advantage for teams that want flexibility or want to optimize costs by routing different tasks to different models.

The limitations are equally real. At 47k stars the project is popular, but the extension ecosystem is still maturing. Seventy-plus extensions sounds substantial, but coverage is uneven compared to a mature package manager - popular use cases are well-served and niche ones are not. Documentation currently assumes you are comfortable debugging agent behavior, and error messages when an extension misbehaves can be sparse.

The Linux Foundation governance move is a positive long-term signal, but it also means some tooling and documentation is catching up to the new organizational home. The project is stable enough for non-critical automation but treat it as a testing environment before relying on it in production pipelines that have real consequences if the agent does the wrong thing.

References

• Goose GitHub repository: https://github.com/aaif-goose/goose
• Goose documentation and installation: https://github.com/aaif-goose/goose/blob/main/README.md
• Model Context Protocol (MCP) overview: https://modelcontextprotocol.io
• MCP servers directory: https://mcp.developersdigest.tech
• Claude Code skills directory: https://skills.developersdigest.tech
• Apache 2.0 License: https://www.apache.org/licenses/LICENSE-2.0