Goose

Goose is a free, Apache-2.0 AI agent that runs on your machine as a desktop app, a CLI and an API. It is a general agent, not only for code, works with 15+ model providers and 70+ MCP extensions, and is built in Rust. It now sits under the Linux Foundation's Agentic AI Foundation. Checked 31 October 2026.

At a glance

What Goose is

The README's description: "goose is a general-purpose AI agent that runs on your machine. Not just for code: use it for research, writing, automation, data analysis, or anything you need to get done." That sets it apart from agents built purely for programming such as Claude Code or Aider, though it does code well with the right extension.

You get a native desktop app, a full CLI and an API to embed it. It works with 15+ providers, using API keys or, through the Agent Client Protocol (ACP), your existing Claude, ChatGPT or Gemini subscriptions. It connects to 70+ extensions through MCP.

Where it came from

Goose began as an open source project from Block, and the docs site was at block.github.io before moving to goose-docs.ai (a visit to the old address redirects). The repository now lives under aaif-goose, and the README says goose is "part of the Agentic AI Foundation (AAIF) at the Linux Foundation." There is a governance file and a "custom distributions" guide for building your own goose with preconfigured providers, extensions and branding.

Foundation governance is a good sign for longevity. It does not guarantee a project's future, but it reduces the risk that one company's change of focus ends it, as happened with Roo Code.

Install

CLI, from the README and quickstart:

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

On Windows, run it in Git Bash, MSYS2 or PowerShell. The desktop app is a download for macOS and Windows (unzip and run), and for Linux a DEB, RPM or Flatpak package (sudo dpkg -i <file>.deb on Debian and Ubuntu). If Windows shows a PATH warning, add goose to your PATH before running goose configure.

Choose a provider

Desktop: the welcome screen offers a quick setup with an API key, a ChatGPT subscription, Agent Router by Tetrate, OpenRouter and other providers.

CLI:

goose configure
# Configure Providers, pick one, enter the key, pick a model
goose session        # start in the current directory
goose session -r     # resume the last session

For GitHub Copilot no API key is needed: an auth code is copied to your clipboard and a browser window opens for you to paste it. If prompted, you can decline to store the key in the keyring, which helps with keyring errors on Windows.

Extensions

Extensions are how goose does things. The docs call them "add-ons that provide a way to extend the functionality of goose", and they are based on MCP. Built-in ones:

There are also platform extensions: Analyze, Extension Manager and Skills and Summon (all enabled by default), plus Apps, Chat Recall, Code Mode, Todo and Top of Mind.

Add your own MCP extension in the desktop app (Extensions, Add custom extension), with goose configure then Add Extension, as a session-only flag (goose session --with-extension "<command>"), through a goose://extension deeplink, or in ~/.config/goose/config.yaml. For remote servers that need OAuth, set a client ID. Goose checks external extensions for known malware before activating them and blocks malicious packages.

See MCP servers to pick extensions, and what are MCP servers for the background.

Safety: it runs autonomously by default

This is the line to read twice. The docs say: "goose runs autonomously by default. With the Developer extension, it can run commands and modify files without your approval." To add oversight, configure the permission mode and tool permissions, described in the Developer MCP guide. Extensions turned on mid-session through automatic detection last only for that session.

Practical advice:

• Set an approval mode before you point goose at a real project.
• Work on a git branch so every change is reviewable.
• Use a container or a separate user for experiments.
• Give extensions the narrowest access they need.

Compare Cline, which asks for approval on every edit and command by default.

Models and cost

Goose is free; models are not. Options:

For prices see LLM API prices. For local setup see local coding agent with Ollama.

A first session

A cautious first run, using only features in the docs:

1. Install the CLI or desktop app and run goose configure to pick a provider. Set a spend cap with that provider first.
2. Before starting, open the permission settings and choose an approval mode. The default is to act without asking.
3. Make a throwaway directory or a branch of a small repository.
4. Start a session with goose session and ask for something small: "Read the README and summarise how to run the tests."
5. Turn on one more extension, such as Computer Controller, only when a task needs it.
6. End with Ctrl+C, and resume the same conversation later with goose session -r.
7. Review everything with git diff and delete the branch if you do not like it.

Because the Developer extension is enabled by default, even the first prompt can touch files. That is why step two comes before step four.

Beyond code

The README insists goose is for "everything in between", and it is the main reason to choose it over a coding-only tool. Examples that fit the extension model, as illustrations of design rather than tested workflows:

• Research. Add a search or fetch extension, ask for a comparison of three libraries with sources, and have it write the notes to a file.
• Data chores. Point it at a folder of CSV files and ask for a cleaned summary table.
• Writing. Draft documentation from the code, then revise it in a second pass.
• Automation. Use the Computer Controller extension for repetitive desktop tasks, with permissions tightened.

For any task that sends information to the model, check what is in the files first. Prompts and file contents go to your provider unless you run a local model.

Teams and custom distributions

Goose offers a route most open agents do not: building your own distribution. The repository has a guide for custom distros with preconfigured providers, extensions and branding. For a company, that means you can ship a goose that already points at your approved model gateway, with only the extensions you have vetted, and the company name on the front.

A sensible team setup:

• choose one approved provider or gateway and set it as the default
• list the allowed extensions and disable the rest
• set a permission mode that requires approval for commands
• keep shared recipes and instructions in a repository
• decide how updates are rolled out, since the CLI and the desktop app update separately

See private AI for teams and AI agent governance for the wider rules.

What it does well

• General purpose. Research, writing and automation as well as code.
• Native app plus CLI plus API. Useful for embedding.
• MCP at the core. 70+ extensions and an easy way to add your own.
• Governance. Linux Foundation home and an Apache-2.0 licence.
• Provider freedom. Including subscription sign-in through ACP and local models.
• Rust. Built for performance and portability.

Limits

• Autonomy by default. Be deliberate about permissions.
• Breadth over depth. A general agent has fewer coding-specific niceties than a tool built only for code.
• Moving address. Old links to block.github.io redirect, and tutorials may name the old organisation.
• Subscription use. Whether a provider allows a subscription in a third-party agent is the provider's decision. Goose's docs describe ACP providers as a way to use an existing Claude Code or ChatGPT Plus or Pro subscription, but read each provider's terms before you rely on it.
• Privacy. Goose runs locally, but prompts go to your provider. The config reference lists GOOSE_TELEMETRY_ENABLED for anonymous usage data, with a default of false.

Why the foundation move matters

An open licence says what you may do with the code. Governance says who decides what goes into it and what happens if the original sponsor loses interest. A foundation home spreads that decision across several members and publishes the rules. For a team choosing a tool that will sit in daily workflows, that is a practical advantage: roadmap changes are less likely to come from a single company's reorganisation. It is still worth reading the governance file in the repository, and watching release dates, because a foundation does not write the code for you. Goose's own release rhythm is healthy at the time of writing, with v1.57.0 on 28 October 2026 and a push two days later.

Goose versus the others

See open source AI agents for the whole list.

Who should pick it

Choose Goose if you want one open agent for more than code, you like MCP, and you want a desktop app as well as a terminal. It suits researchers, operations people and developers who automate chores. Skip it if you want an agent that approves each edit by default, or if you want an editor-integrated experience.

Recipes and repeatable work

The quickstart links to a Recipe Cookbook. Goose's docs describe recipes as reusable workflows that package extensions, prompts and settings, and that you can share with your team; see the recipe reference guide for the exact format. The practical idea matters either way: when you find a prompt, extension set and permission mode that works for a chore, write it down in a file in your repository so a teammate, or you next month, can run the same thing. Keep recipes small and name them for the job, such as "weekly dependency report".

Troubleshooting

• "goose: command not found". Restart the terminal after install, and on Windows add goose to your PATH before running goose configure.
• Keyring errors. If prompted, choose not to store the key in the keyring, as the quickstart suggests.
• An extension will not start. Check its command in ~/.config/goose/config.yaml, and try adding it for one session with goose session --with-extension.
• The agent does too much. Tighten the permission mode and tool permissions before the next session.
• Old links break. Documentation moved to goose-docs.ai, and the repository moved to aaif-goose.

Our take

This is an editorial reading of the repository and docs, not a hands-on test.

Goose is the open source agent with the clearest claim to be more than a coding tool, and its move to the Linux Foundation makes it a safer bet than most projects of its age. The documented design is simple: an agent loop, MCP extensions and a choice of providers.

The main thing to manage is autonomy. The default is to act without asking, so set permissions first, work on a branch and choose extensions carefully. If you want a coding-only workflow with approval at every step, Cline suits better; if you want a general agent that can also write code, Goose is the one to try. As with any open tool, keep your instructions and recipes in files you control.

Checklist

• Install the CLI or the desktop app
• Run goose configure and choose a provider
• Set permission mode and tool permissions before real work
• Enable only the extensions you need
• Work on a git branch
• Set a spend cap with your model provider
• Check the provider's terms if you use a subscription through ACP