↓ Skip to main content
9 – 17 UHR +49 8031 3508270 LUITPOLDSTR. 9, 83022 ROSENHEIM
DE / EN
Coding agent Agentic AI Foundation (Linux Foundation) United States Desktop app, Terminal, ACP

Goose

Goose is the Agentic AI Foundation's open-source AI agent for desktop and terminal: MCP extensions, more than 85 model providers and custom endpoints.

Licence Apache-2.0
First release January 2025 (version 1.0)
Interfaces Desktop app, Terminal (CLI), ACP server (e.g. for Zed), Rust library oi-kit (alpha)
Platforms macOS, Linux, Windows
Instruction file AGENTS.md, .goosehints

The seven building blocks in Goose

How Goose implements the building blocks of an AI harness

  1. 1

    Agent loop

    The agent loop runs interactively in the desktop app or with goose session in the terminal, headless with goose run (task via -t, file via -i or through a pipe), and as an ACP server (goose acp) behind editors such as Zed or your own applications.

  2. 2

    Tools and execution environment

    Tools come from extensions built on the Model Context Protocol. Built-in extensions such as the developer toolset can be supplemented with any MCP server; organizations restrict the choice through a central allowlist.

  3. 3

    Context management

    Per the documentation, Goose reads project rules from AGENTS.md first, then from .goosehints, plus global hints in ~/.config/goose/. The CONTEXT_FILE_NAMES variable also pulls in CLAUDE.md or .cursorrules; skills and prompt templates add further context.

  4. 4

    State and memory

    Sessions are stored locally in an SQLite database (on Linux and macOS under ~/.local/share/goose/sessions/) and can be resumed with goose session --resume or branched into a new session with --fork.

  5. 5

    Permissions

    Three modes control autonomy: Autonomous is the documented default and works without asking, Manual Approval asks before every tool, Smart Approval approves low-risk actions and flags others for confirmation. Per-tool permissions refine this.

  6. 6

    Verification and feedback

    Optional pattern-based prompt injection detection checks for dangerous commands. In Adversary Mode, an independent reviewer agent also rates every tool call before execution with ALLOW or BLOCK.

  7. 7

    Orchestration

    Subagents handle subtasks sequentially or in parallel in separate instances, per the documentation only in Autonomous mode. Recipes bundle extensions, prompts and settings into shareable workflows, and subrecipes allow nested flows.

Models and model access

Which models the harness uses and how they are obtained

Models and model access
Models No fixed default model: you choose provider and model during setup with goose configure or in the desktop app
Access routes Anthropic, OpenAI, Google Gemini and Vertex AI, Amazon Bedrock, Azure OpenAI and Azure AI Foundry, OpenRouter, Databricks, GitHub Copilot, Mistral AI, LiteLLM, Ollama, LM Studio, Claude Code and Codex via ACP, custom OpenAI, Anthropic or Ollama compatible endpoints
Free choice of model Yes
Custom endpoint / LLM gateway Yes
Per the documentation, the OpenAI provider connects to any OpenAI-compatible endpoint via OPENAI_HOST and OPENAI_BASE_PATH, and OPENAI_CUSTOM_HEADERS adds custom headers. You can also create custom providers in OpenAI, Anthropic or Ollama format with API URL, key and model list as a JSON file.
Features
MCP servers Sub-agents Hooks Skills Plugins / extensions Headless / CI SDK IDE integration Resume sessions
Running it with herdr
Supported by herdr No
State detection Not documented
Integration None
The herdr documentation (version 0.9.5, retrieved on 22 November 2026) lists Goose neither among the integrations supported by herdr nor among those supported by the agent itself.
More about herdr →

Enterprise use

Data processing, controls and pricing model according to the vendor

Data processing

Goose runs locally and sends prompts, file contents and tool results to the chosen model provider; per the documentation, that provider's retention and privacy policies then apply. With local models, Goose can run without any cloud access.

Telemetry

On first launch, Goose asks whether it may send anonymous usage data (opt-in). Per the documentation this covers items such as operating system, version, provider, model and token counts, but no conversations and no code. Controlled via GOOSE_TELEMETRY_ENABLED.

Admin controls

A YAML list referenced via GOOSE_ALLOWLIST defines which MCP servers may be installed as extensions. Custom distributions ship Goose to teams with preconfigured providers, extensions and custom branding.

Permissions

The default Autonomous mode changes and deletes files without asking. Organizations should set Manual or Smart Approval as the default; the documentation does not describe a built-in sandbox and covers isolation by running Goose in Docker.

Governance and pricing

Block contributed Goose to the Linux Foundation's Agentic AI Foundation as a founding project in December 2025. The software is free under Apache-2.0; costs arise only from the model providers you use.

Strengths
  • Desktop app and CLI for macOS, Linux and Windows with a shared configuration
  • More than 85 model providers per the README, plus local models running in-process without a separate model server
  • Custom endpoints in OpenAI, Anthropic or Ollama format including custom headers
  • Vendor-neutral governance in the Linux Foundation's Agentic AI Foundation, Apache-2.0
  • Enterprise building blocks such as an extension allowlist, custom distributions, prompt injection detection and Adversary Mode
  • Recipes and subrecipes for repeatable workflows that teams can share
Limitations
  • The default Autonomous mode runs file and tool actions without asking
  • No built-in sandbox documented; isolation only via Docker or container extensions
  • Subagents are available only in Autonomous mode per the documentation
  • No central user or role management for Goose itself documented
  • A fast release cadence with several versions per week requires version management in organizations
  • Not currently supported by herdr

Use cases

Typical tasks for this harness

Development in the terminal or in a desktop app with a freely chosen model
Sharing recurring workflows as recipes across the team and automating them with goose run
Working with local models without cloud access for confidential projects
Organization-wide rollout as a custom distribution with a preconfigured gateway provider and allowlist
Agent backend for your own applications or editors via ACP
Research, data and automation tasks beyond code

Goose is an open-source AI agent for desktop and terminal, developed by Block and handed over to the Linux Foundation’s Agentic AI Foundation in December 2025. As an AI harness, Goose connects a freely chosen language model to files, shell and tools through MCP extensions. As of 22 November 2026.

What is Goose?

Goose is a general-purpose agent for programming, research, writing, automation and data analysis, available as a desktop app and as a CLI for macOS, Linux and Windows. Block, the company behind Square and Cash App, released version 1.0 on 28 January 2025 according to GitHub. Per the Linux Foundation press release of 9 December 2025, Goose is one of the three founding projects of the Agentic AI Foundation (AAIF), alongside MCP and AGENTS.md. The repository now lives at aaif-goose/goose; per the GitHub API, the old path block/goose redirects there.

The project is very active: per the GitHub API it has 56,867 stars, the current version per the releases is 1.60.2 from 20 November 2026, and eight versions shipped between 9 and 20 November 2026 alone (as of 22 November 2026). You install the CLI with the install script from the README and the desktop app from the download page in the documentation.

Goose as an AI harness

Goose covers all seven building blocks of a harness itself. Tools come from extensions that, per the documentation, are built on the Model Context Protocol; any MCP server can be added as an extension. The agent loop runs interactively in the app or with goose session, headless with goose run for scripts and CI, and as an ACP server (goose acp), which the Zed editor, for example, uses to launch Goose as its agent. Goose reads project rules from AGENTS.md first, then from .goosehints.

Per the documentation on permission modes, three modes control autonomy: Autonomous (default, no prompts), Manual Approval (confirmation before tools) and Smart Approval (risk-based approval). Subagents handle subtasks in parallel but are only active in Autonomous mode. Recipes bundle extensions, prompts and settings into reusable workflows; hooks, skills and plugins follow open specifications. If you want to build your own agents, the Rust library oi-kit is available, which per the README is still in alpha.

Models and model access

Goose is model-agnostic and, per its README, connects to more than 85 providers, including Anthropic for Claude, OpenAI for GPT, Google for Gemini, Amazon Bedrock, Azure OpenAI, OpenRouter and Databricks. Local models run via Ollama, LM Studio or directly inside the Goose process without a separate model server. Through the Agent Client Protocol, Goose can also use Claude Code or Codex with their subscriptions as providers.

Custom endpoints are explicitly supported per the provider documentation: the OpenAI provider connects to any OpenAI-compatible service via OPENAI_HOST and OPENAI_BASE_PATH, and OPENAI_CUSTOM_HEADERS sets custom headers. For multiple endpoints you create custom providers in OpenAI, Anthropic or Ollama format, which can be shared across the team as JSON files. This lets you run Goose in proxy mode through the AI Gateway, which checks permissions and budgets and assigns every token to a cost center.

Enterprise use: data protection and governance

Goose runs locally and sends prompts and code only to the chosen model provider; per the documentation, that provider’s retention and privacy policies then apply. Goose stores sessions in a local SQLite database. Per the telemetry documentation, Goose sends anonymous usage data only after consent on first launch; conversations and code are not included.

For organizational control, Goose offers an extension allowlist that is loaded from a central URL via GOOSE_ALLOWLIST, as well as custom distributions with preconfigured providers and extensions. Check the default mode: Autonomous changes and deletes files without asking, and the documentation does not describe a built-in sandbox. Set Manual or Smart Approval as the default, enable prompt injection detection and Adversary Mode where needed, and isolate risky tasks in Docker. Regardless of that, source code and prompts belong in your record of processing activities.

Running Goose with herdr and Orca

Goose is not currently supported by herdr: the herdr agent list in version 0.9.5 does not name Goose. Orca lists Goose in its own agent overview with automatic setup, without deeper integration such as status reporting or hooks. There you can start several Goose sessions in parallel, each in its own Git worktree.

How does Goose differ from Claude Code and Codex?

Goose is vendor-neutral, whereas Claude Code and Codex come from the model vendors Anthropic and OpenAI and are tailored to their models and subscriptions. Goose is governed by a Linux Foundation project foundation, offers a desktop app alongside the CLI and also targets tasks beyond code. OpenCode is similarly open in model choice but focuses on the terminal. One important difference in daily use: Goose starts in Autonomous mode without a sandbox, Claude Code asks before file changes and shell commands in its default mode, and Codex limits actions through a sandbox with an approval policy.

Where it fits: developer harness and enterprise harness

Goose is a harness for developers and technically skilled teams. For business users who work without a terminal, CompanyGPT is the matching harness, with MCP tools, enterprise knowledge and roles from Entra ID or Keycloak. The AI Gateway provides the shared cost and governance layer; per the product page, its companion measures agent time for Claude Code, Codex, OpenCode, Pi, GitHub Copilot CLI and Gemini CLI, so you capture Goose through proxy mode. Our overview of AI harnesses covers further coding agents and orchestrators.

From developer harness to enterprise harness

Coding harnesses are tools for developers. Business users, cost control and governance need two more layers.

CompanyGPT – the harness for business users

CompanyGPT gives any language model tools via MCP servers, integrations and n8n, company knowledge via companyRAG, roles from Entra ID or Keycloak, and audit logs – operated in your own cloud tenant (Azure, AWS or Google Cloud) or sovereignly on STACKIT.

Discover CompanyGPT
AI Gateway – cost and governance for every agent

The AI Gateway bundles the model access of your tools and coding agents behind an OpenAI-compatible API: sign-in via Entra ID, Keycloak or Cognito, budgets and hard limits per team and user, cost attribution per project and repository via the Companion, and logging of every request.

View the AI Gateway

Frequently Asked Questions

What is Goose?

Goose is an open-source AI agent for desktop and terminal, developed by Block and handed over to the Linux Foundation's Agentic AI Foundation in December 2025. Goose connects a freely chosen language model to files, shell and tools through MCP extensions and suits programming, research and automation. The aaif-goose/goose repository is licensed under Apache-2.0.

Is Goose open source and free?

Yes. Goose is licensed under Apache-2.0, which permits commercial use, modification and redistribution. The desktop app and CLI are free, and the project offers no paid subscription. Costs arise solely from the model providers you connect, for example by token usage or through existing subscriptions such as GitHub Copilot or ChatGPT.

Which models does Goose support?

Goose is model-agnostic and, per its README, connects to more than 85 providers, including Anthropic, OpenAI, Google Gemini, Amazon Bedrock, Azure OpenAI, OpenRouter and Databricks. Local models run via Ollama, LM Studio or directly inside the Goose process. Through the Agent Client Protocol, Goose can also use Claude Code or Codex as providers.

Does Goose work with a custom endpoint or the innFactory AI Gateway?

Yes. The OpenAI provider accepts any OpenAI-compatible endpoint via OPENAI_HOST, and custom providers map OpenAI, Anthropic or Ollama compatible APIs with custom headers. This lets you run Goose in proxy mode through the AI Gateway, which checks budgets and bills tokens. The gateway companion's agent time measurement does not currently cover Goose.

Can Goose be used in a GDPR-compliant way?

That depends mainly on the model provider. Goose itself runs locally, stores sessions in a local database and sends usage data only with consent. Prompts and code, however, go to the chosen provider, which must be covered contractually and in your record of processing activities. EU endpoints, your own gateway or local models keep processing under control.

How does Goose differ from Claude Code and Codex?

Claude Code and Codex come from the model vendors Anthropic and OpenAI and are geared to their models and subscriptions. Goose is vendor-neutral, governed by a Linux Foundation project foundation and offers a desktop app alongside the CLI. Important in practice: Goose runs autonomously without a sandbox by default, while Claude Code asks before changes and Codex limits actions through a sandbox with an approval policy.

Introduce coding agents safely in your company

We support selection, model access in the EU, permission design and cost control.