Which LLMs and extensions does goose support?

goose supports 15+ LLM providers — including Anthropic, OpenAI, Google, Ollama, OpenRouter, Azure, and Bedrock — and connects to 70+ extensions through the Model Context Protocol (MCP), covering databases, APIs, browsers, GitHub, Google Drive, and more. You can authenticate with API keys or, via the Agent Client Protocol (ACP), with existing Claude, ChatGPT, or Gemini subscriptions. If a service you need isn't in the extension list, you can add a skill or build your own extension.

LLM providers

goose is provider-agnostic. According to the project's documentation, it works with 15+ providers, with these named explicitly:

Two things are worth separating here:

• API keys are the standard path. You supply a key for the provider you want, and goose routes requests through it.
• Existing subscriptions work through ACP. If you already pay for Claude, ChatGPT, or Gemini, goose can use that subscription as a provider rather than requiring a separate API key. This is the detail most people miss when estimating cost — it means you may not need to buy additional API credits to get started.

The list above is what the documentation names; "15+" signals there are more providers than the seven called out. Check the provider configuration docs for the current full list before assuming a specific provider is supported.

Extensions via MCP

Extensions are how goose reaches your tools and data. They're built on the Model Context Protocol (MCP), an open standard for connecting AI agents to tools and data sources. goose was one of the earliest adopters and describes its integration as one of the deepest in the ecosystem, with 70+ documented extensions.

Named categories and examples from the documentation:

• Databases — query and inspect data sources
• APIs — connect to external services
• Browsers — let the agent interact with web content
• GitHub — repositories, issues, and code workflows
• Google Drive — files and documents

Because MCP is an open standard rather than a goose-specific format, extensions written for MCP generally target the same protocol goose speaks. That's the practical reason the extension count keeps growing: contributors aren't writing to a proprietary interface.

If your service isn't listed

Two paths:

1. Add a skill — a lighter-weight way to teach goose a capability without building a full extension.
2. Build your own extension — for services that need a real tool integration.

Both are documented, and the community extension directory is where you'd check first in case someone has already built what you need.

How to decide whether goose fits your stack

Work through these in order:

1. Is your model provider named? If you use Anthropic, OpenAI, Google, Ollama, OpenRouter, Azure, or Bedrock, you're covered directly. If you use something else, confirm it against the full provider list.
2. Do you already have a Claude, ChatGPT, or Gemini subscription? If so, ACP may let you use it instead of provisioning API keys — worth checking before you budget for API spend.
3. Is your tool in the extension list? Check the MCP extension directory for your database, API, or service. GitHub and Google Drive are confirmed; niche internal services likely are not.
4. If it's not there, how much work is a custom extension? If it's a simple capability, a skill may be enough. If it needs real tool semantics, plan for extension development.

What goose runs on

The same agent is available three ways, which matters if your team spans different workflows:

• Desktop app — native for macOS, Linux, and Windows
• CLI — for terminal workflows
• API — to embed goose anywhere

It's built in Rust for performance and portability. goose also works as an ACP server, so you can connect from Zed, JetBrains, or VS Code, and it can use ACP agents like Claude Code and Codex as providers — the reverse direction of the subscription support described above.

Governance and longevity

goose is part of the Agentic AI Foundation at the Linux Foundation, which the project describes as ensuring it remains vendor-neutral, community-governed, and open for the long term. For teams evaluating whether to build on it, that's the relevant signal: the project isn't controlled by a single vendor whose priorities could shift.

Community channels — Discord for questions and help, GitHub for issues and contributions — are where extension and recipe development happens in the open.