goose: Open Source AI Agent for Desktop and CLI

What goose is

goose is an open-source, general-purpose AI agent that runs on a developer's own machine. It ships as a native desktop app for macOS, Linux and Windows, a full CLI for terminal workflows, and an API for embedding it elsewhere, all built in Rust. The project's own tagline is that it goes beyond code suggestions to install, execute, edit and test with any LLM, and the README is explicit that coding is only one of its jobs: research, writing, automation and data analysis are all in scope.

The problem goose tackles is the gap between a chat model and getting work done. A language model on its own takes text in and returns text out. goose wraps that loop with tools, so a request like "create a browser-based tic-tac-toe game" turns into a plan, files written to disk, commands run, and results fed back to the model until the job is finished. Those tools come from extensions built on the Model Context Protocol (MCP), which means goose can use the same MCP servers as other agent hosts.

Two things set goose apart from many agents in the same space. First, it is model-agnostic: the README lists support for more than 15 providers, including Anthropic, OpenAI, Google, Ollama, OpenRouter, Azure and Bedrock, and it can also use existing Claude, ChatGPT or Gemini subscriptions through the Agent Client Protocol (ACP). Second, governance: goose is part of the Agentic AI Foundation (AAIF) at the Linux Foundation, and the repository publishes a governance document rather than being steered by a single vendor's roadmap.

The audience is broad. Developers use it as a coding agent in the terminal or in editors such as Zed and JetBrains IDEs; teams use recipes to share repeatable workflows; and organizations can build custom goose distributions with their own preconfigured providers, extensions and branding.

How it works

The architecture documentation describes three components. The interface is the desktop app or CLI that collects input and displays output. The agent runs goose's core logic and manages the interactive loop. Extensions provide the tools the agent can call, such as running shell commands or managing files. In a typical session the interface starts an agent, which connects to one or more extensions at once, and the interface can create several agents to work on different tasks concurrently.

The interactive loop itself has six steps in the docs:

1. Human request. The user gives goose a task, question or problem.
2. Provider chat. goose sends the request plus the list of available tools to the configured LLM provider, which may respond with a tool call.
3. Model extension call. The model can describe a tool call but cannot execute it, so goose takes the JSON-formatted call, runs it and gathers the result.
4. Response to model. The result goes back to the model, and the cycle repeats as long as more tools are needed.
5. Context revision. goose removes old or irrelevant information so the model focuses on what matters and token usage stays under control.
6. Model response. Once tool calls are done, the model replies and the loop waits for the next user message.

Errors are part of the loop rather than a reason to stop. The docs explain that invalid JSON, missing tools and execution errors are sent back to the model as tool responses, giving it the information it needs to correct course and continue.

Token cost gets explicit attention. The architecture page notes that while goose is free, LLM usage usually is not, and lists the techniques goose uses to keep context lean: summarizing with faster and smaller models, deleting old or irrelevant content algorithmically, using find-and-replace instead of rewriting large files, using ripgrep to skip system files, and summarizing verbose command output.

ACP runs in both directions. goose acp starts goose as an ACP server over stdio so editors like Zed and JetBrains IDEs can connect to it directly. In the other direction, goose can delegate to external ACP agents such as Claude Code or Codex as providers; the external agent handles tool execution itself, and goose passes its configured extensions through as MCP servers.

Key features

• Desktop app, CLI and API. The same agent is available as a native desktop application on macOS, Linux and Windows, as a terminal CLI, and as an API for embedding.
• Bring your own model. More than 15 providers are supported, including local models through Ollama, and the CLI's goose configure flow walks through choosing a provider and model.
• Subscription providers via ACP. Existing Claude, ChatGPT or Gemini subscriptions can be used through ACP rather than separate API keys.
• MCP extensions. The README cites 70+ extensions available through MCP, alongside built-in extensions for development, web scraping, automation and memory. Custom extensions can be built and added.
• Permission modes. Four modes control autonomy: Completely Autonomous, Manual Approval, Smart Approval (risk-based auto-approval of low-risk actions) and Chat Only. Granular per-tool permissions are supported in the approval modes.
• Recipes. Reusable workflows packaging instructions, an optional starting prompt, required extensions, provider and model settings, and retry logic with shell-command success checks, defined in YAML or JSON or created in the desktop app.
• Subrecipes. The recipe documentation covers subrecipes and storing recipes for reuse across a team.
• Sessions. Each session is a continuous conversation; the CLI can resume the last one with goose session -r.
• Context hints. goosehints give goose a set of project-specific hints to use within sessions, part of the documentation's context-engineering guides.
• Editor integration. As an ACP server, goose plugs into Zed and JetBrains IDEs.
• Custom distributions. CUSTOM_DISTROS.md describes building a branded goose with preconfigured providers and extensions.
• Security tooling. The documentation includes guides on prompt-injection detection and an adversary mode under its security section.

Getting started

The desktop app is downloaded from the installation page for each operating system. On macOS, Homebrew can install and update either variant:

brew install --cask block-goose

brew install block-goose-cli

The CLI can also be installed on macOS, Linux and Windows (from Git Bash, MSYS2 or PowerShell) with the project's install script:

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

Next, configure a provider. In the CLI:

goose configure

Choosing Configure Providers lists the supported providers, from Amazon Bedrock and Anthropic to Azure OpenAI, ChatGPT Codex and Claude Code CLI; goose then prompts for the provider's API key and lets the user pick a model from a fetched list. GitHub Copilot is a special case that uses a generated authentication code instead of an API key. The quickstart uses Tetrate Agent Router Service as its example provider and notes a $10 free-credit offer for first-time authentication through goose, but any supported provider works.

Start a session from an empty project directory:

goose session

From there, instructions are typed as they would be said to another developer. The quickstart's example prompt asks goose to build a browser-based tic-tac-toe game against a bot; goose plans the work and writes the JavaScript and HTML files. Enabling the built-in Computer Controller extension (via goose configure, then Add Extension, Built-in Extension) gives it the ability to open a browser, and the previous session can be resumed:

goose session -r

To use goose from an editor, run it as an ACP server with goose acp and point Zed or a JetBrains IDE at it, following the editor-specific guides in the documentation.

Permission modes and safety

How much goose is allowed to do on its own is the single most important configuration choice, and the documentation spells out the options in a table:

• Completely Autonomous: goose can modify files, use extensions and delete files without approval.
• Manual Approval: goose asks for confirmation before using any tool or extension.
• Smart Approval: a risk-based approach that auto-approves low-risk actions and flags others.
• Chat Only: no extension use or file changes, just conversation.

The docs carry a warning that Autonomous mode is applied by default. Each session has its own mode; the default for new sessions is set in the desktop app's Chat settings or in the CLI under goose configure and goose settings, and the mode can be switched mid-session with commands such as /mode approve or /mode smart_approve. For a first run on a real codebase, starting in an approval mode is the safer choice.

Data handling is split in two. goose's own telemetry is opt-in: on first use it asks permission to collect anonymous usage data, limited according to the docs to operating system and architecture, goose version and install method, provider and model, extension and tool usage counts (names only), session metrics such as duration and token usage, and error types without details. It does not include conversations, code, tool arguments, error messages or personal data, and can be toggled later in settings or with GOOSE_TELEMETRY_ENABLED. Separately, everything goose sends to an LLM provider is subject to that provider's retention and privacy policies, which is the more significant exposure for most teams.

Recipes

Recipes are goose's answer to repeatable work. A recipe bundles a title, description and instructions that define the model's behaviour, plus optional fields for a starting prompt, the extensions it needs, example activities shown in the desktop app, provider and model settings including temperature, and a retry block. The retry block is the interesting part for automation: it sets a maximum number of attempts, a list of shell-command checks that decide whether the run succeeded, and an optional cleanup command on failure.

Recipes can be created in the desktop app's Recipes panel, saved to a recipe library, shared as a link, or written by hand as YAML or JSON. The docs also cover subrecipes for composing workflows and storing recipes for teams. In practice this turns a well-tuned prompt and tool setup into something a colleague can run with one click instead of reconstructing it from a chat transcript.

Use cases

• Terminal coding agent. Building features, fixing bugs and running tests in a repository from goose session, with the model of choice behind it.
• Editor agent. Running goose as an ACP server inside Zed or a JetBrains IDE.
• Orchestrating other agents. Using Claude Code or Codex as ACP providers while goose supplies the extensions and interface.
• Team workflows. Packaging a release checklist, code review routine or data-cleaning job as a recipe with success checks so it runs the same way every time.
• Local-model work. Pairing goose with Ollama for tasks where code or data should not leave the machine, accepting the capability trade-offs of smaller models.
• Non-code automation. Research, writing and data analysis tasks using MCP extensions such as Google Drive search or web scraping.
• Internal distributions. Shipping a company-branded goose with approved providers and extensions preconfigured.

How it compares

goose sits in a crowded category of AI agents and coding assistants. Its documentation itself names Claude Code and Codex, but as agents goose can delegate to through ACP rather than as rivals, which says something about its positioning: it aims to be the host and interface that can work with many models and many agents, not a front end tied to one vendor's model. Compared with vendor-specific terminal agents, the main differentiators are provider neutrality, the desktop app alongside the CLI, MCP-based extensibility and foundation governance.

The flip side is that a model-agnostic agent cannot be tuned as tightly to one model family as a vendor's own tool, and results depend heavily on which provider and model are configured. Any comparison is best made on a team's own repositories with the models it actually plans to pay for.

Things to know before adopting

• Autonomous by default. As noted above, the default permission mode lets goose modify and delete files without approval. Change the default before pointing it at anything important.
• Model costs are separate. goose is free and Apache-2.0 licensed, but LLM usage is billed by the provider. The context-revision features reduce tokens; they do not eliminate the cost.
• Provider data policies apply. Prompts, code and anything goose reads may be sent to the configured provider. Local providers avoid that at the cost of model capability.
• Install script pipes to bash. The CLI install path is curl ... | bash. Homebrew packages are an alternative on macOS, and reviewing the script first is reasonable practice.
• Package names. The Homebrew cask and formula are named block-goose and block-goose-cli, while the repository lives under the aaif-goose organization; search for both when looking for packages.
• Windows specifics. The quickstart warns about PATH warnings after installation and advises choosing not to store credentials in the keyring if prompted, pointing to the installation guide for keyring errors.
• macOS permissions. The installation guide notes the desktop app needs access to create its log directory and links to known-issues steps when permissions block it from loading.
• Fast release pace. Releases land roughly weekly (v1.55.0, v1.56.0 and v1.57.0 all shipped in the second half of October 2026), so pin versions in shared environments and read release notes before upgrading.
• Telemetry is opt-in. Anonymous usage data is collected only after the user agrees on first run.

Project activity

As of October 2026 the repository has about 56,000 stars on GitHub and roughly 6,500 forks. It was created in August 2024, is written primarily in Rust and is licensed under Apache-2.0. The latest release at the time of writing is v1.57.0, published on 28 October 2026, and commits land daily. The project is part of the Agentic AI Foundation at the Linux Foundation and runs community channels on Discord, YouTube, LinkedIn and X.

Source code, governance and releases are at github.com/aaif-goose/goose, documentation including the quickstart and installation guide at goose-docs.ai, and the foundation at aaif.io.