Goose

Goose runs as a native desktop application on macOS, Windows, and Linux. You can also use it from the command line or integrate it via its API. The core experience starts with connecting a model provider: Anthropic, OpenAI, Google, OpenRouter, Azure, Bedrock, or any of the 15+ supported providers. For local models, you point Goose at Ollama running on your machine.

Once connected, you interact with Goose through a chat interface or the CLI. The agent can read and write files, execute shell commands, install packages, run tests, and interact with your browser, databases, GitHub repositories, and Google Drive through MCP extensions. It supports subagents that handle parallel tasks independently, keeping the main conversation focused.

Goose works with cloud models and local models. For cloud models, you use API keys from your provider of choice. For local models, you run Ollama separately and connect Goose to it. The agent does not include built-in local inference, so local performance depends entirely on your hardware and the model you choose.

The desktop app exposes a full CLI and an API, so workflows you prototype in the GUI can be scripted and automated later. Recipes let you save repeatable workflows as portable YAML configs that include instructions, extensions, parameters, and subrecipes.

Goose runs on macOS (including Apple Silicon), Windows, and Linux. The desktop app is built with Electron and React, with native installers for each platform.

Pricing: Goose is free and open source under Apache 2.0. You pay only for the model providers you use. Cloud API calls cost whatever your provider charges. Local models require hardware capable of running them through Ollama.

Hardware requirements: There are no hard minimums, but the practical threshold depends on what you want to run. For cloud models, any modern machine with an internet connection works. For local models through Ollama, you need a machine capable of running the model you choose. Apple Silicon Macs with unified memory work well for 7B to 13B parameter models. Windows and Linux machines benefit from NVIDIA GPUs with sufficient VRAM.

Open source status: Apache 2.0. The full source is on GitHub. No paid tiers, no enterprise gate, no feature restrictions based on subscription level.

Beyond code suggestions. Goose installs, executes, edits, and tests code on your machine. It does not just describe what to do; it does it. This means it can clone a repository, install dependencies, run the test suite, make changes based on failures, and re-run tests.

Any LLM. Goose works with 15+ providers including Anthropic, OpenAI, Google, Ollama, OpenRouter, Azure, and Bedrock. You can use API keys or your existing Claude, ChatGPT, or Gemini subscriptions through the Agent Client Protocol (ACP).

MCP extensions. Goose connects to 70+ documented extensions over the Model Context Protocol. These cover databases, APIs, browsers, GitHub, Google Drive, file systems, and more. The ecosystem of available MCP extensions is much larger; the 70+ figure represents the documented and tested set.

Recipes and subagents. Save workflows as YAML recipes that can be shared with teams, run in CI, or reused across projects. Subagents handle parallel tasks like code review, research, and file processing while the main conversation continues.

Security features. Prompt injection detection, tool permission controls, sandbox mode, and an adversary reviewer that monitors for unsafe actions.

Built in Rust. The core is written in Rust for performance and portability across platforms.

Automating multi-step work. Hand off chores like refactors, data cleanup, and repetitive tasks to Goose and let it carry them out. This works well for developers who spend time on mechanical but necessary code changes.

A coding agent in the terminal or a window. Use the same agent from the CLI or the desktop app to write, run, and test code end to end. The agent can work across your entire project, not just individual files.

Connecting your own tools and data. Wire in databases, GitHub, Google Drive, and browsers through MCP so the agent can act across them. This is useful for teams that need an agent that understands their specific toolchain.

Research and analysis. Goose can search the web, read documents, and compile information. It is not limited to code tasks.

Who this fits best: Developers and technical teams who want an open source agent that can act on their machine, are comfortable bringing their own models, and need deep integration with existing tools through MCP.

Who should look elsewhere: Users who want a simple chat interface with built-in local models should consider LM Studio, Jan, or Msty. Users who want a model manager should use Ollama. Users who want a cloud-only experience with no installation should consider Claude Desktop or ChatGPT.

Installation. Download the desktop app from goose-docs.ai. On macOS, you can also install via Homebrew: brew install --cask block-goose. The app supports one-click install on all three platforms.

First steps. After installation, launch the desktop app. You will need to connect a model provider. For cloud models, enter your API key for Anthropic, OpenAI, or another supported provider. For local models, ensure Ollama is running on your machine and Goose will detect it automatically.

What you need. An internet connection for cloud models. For local models, Ollama installed and running with a model you have pulled. The Goose documentation at goose-docs.ai covers setup for each provider and MCP extension.

Community. The project has an active Discord community and a GitHub repository with 50,000+ stars, 5,000+ forks, and 450+ contributors. Documentation covers installation, configuration, recipes, and extension development.

Goose vs. LM Studio. LM Studio is a model manager and chat GUI for running local LLMs. It handles model downloads, inference, and chat. Goose is an agent that runs on your machine and uses models from providers or Ollama. If you want to browse and run local models with a clean interface, use LM Studio. If you want an agent that can edit files, run commands, and connect to your tools, use Goose. They complement each other: you can run models in LM Studio and connect Goose to its local API.

Goose vs. Ollama. Ollama is a model runner and server. It downloads, manages, and serves local models. Goose is an agent that uses models from Ollama or cloud providers. They are not competitors; Goose depends on Ollama for local inference. If you only need to run models locally, use Ollama. If you need an agent that can act on those models, add Goose.

Goose vs. Claude Desktop. Claude Desktop is Anthropic's desktop app for their Claude models. It is closed source, cloud-only, and tied to Anthropic. Goose is open source, works with any provider, and runs locally. If you want a polished, supported experience with Anthropic's best models, Claude Desktop is simpler. If you want vendor independence, local models, and deep extensibility, Goose is the better choice.

Goose vs. Codex CLI. Codex CLI from OpenAI is a terminal-based coding agent. Goose offers the same CLI capability plus a desktop GUI, MCP extensions, subagents, recipes, and support for 15+ providers instead of just OpenAI. Goose is also fully open source under Apache 2.0.

• It runs real actions on your machine, editing files and running commands, so it needs oversight.
• No built-in local inference. You bring your own models through a provider or Ollama.
• The app is free, but capable models still cost money or need decent local hardware.

• Beyond code suggestions

  Goose installs, executes, edits, and tests. It does the work on your machine rather than just describing it.

• Works with any LLM

  Connect 15+ providers including Anthropic, OpenAI, and Google, or run local models through Ollama.

• Extensions through MCP

  Add 70+ extensions over the Model Context Protocol to plug in tools, data sources, and services.

• Recipes and subagents

  Save repeatable workflows as recipes and hand parallel tasks to subagents.