Most AI agents you can buy answer one question for you before you ever open them: whose model, and whose cloud? The agent and the model ship together, the tools live in the vendor's plugin catalog, and your daily workflow rides on one company's pricing and uptime. goose answers differently. It's a free, on-machine agent from Block that runs on your own laptop, drives any model you hand it a key for, and connects to tools over the open Model Context Protocol instead of a proprietary plugin format. As of mid-2026 it's at roughly 29K GitHub stars and — the part founders should note — it's now a Linux Foundation project.

What it is: an open-source (Apache-2.0) AI agent that goes beyond code suggestions to actually do things — install dependencies, edit files, run commands, execute and test code — and reach into GitHub, Jira, Slack, databases, and monitoring dashboards through MCP. It ships as a CLI and a desktop app on macOS, Linux, and Windows.

What it is#

goose runs where your code already is: on your machine. That single fact drives most of what's interesting about it.

Because it's local, it can act like a developer rather than a chat window — it has a shell, it can run your test suite, and it can iterate on the result. Because it's model-agnostic, you point it at whatever LLM makes sense: a frontier hosted model from Anthropic, OpenAI, or Google, a cheaper router, or a model you run yourself. It supports 30+ providers, and with Ollama you can run it against a local open model at zero API cost. And because tool access goes through MCP — the same standard the rest of the agent ecosystem is standardizing on — its 70+ extensions reach 3,000+ tools without goose needing a bespoke integration for each one. If it has an MCP server, goose can talk to it.

The design premise is that the agent should own neither your model nor your tools. You bring both, and swap either whenever you want.

Who it's for#

goose is for technical founders and small teams who want an autonomous agent with control and portability, and who are comfortable spending ten minutes on setup to get it. You keep your source on your own disk (which matters for regulated or sensitive work), you're never locked to one model vendor's pricing, and you wire in the tools you already run.

It is not the right pick for a non-technical user who wants a polished, supported, point-and-click product. goose rewards people who are happy to run goose configure, paste an API key, and reason about which extension to enable.

How to start#

Install the CLI in one command:

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

Or grab the desktop app on macOS with Homebrew:

brew install --cask block-goose

Then configure a provider and a model:

goose configure
# → Configure Providers → pick Anthropic / OpenAI / Google / Ollama / …
# → paste your API key, choose a default model

Add a tool by pointing goose at an MCP extension:

goose configure
# → Add Extension → Built-in (e.g. Developer, Computer Controller)
#   or Remote Extension (Streaming HTTP / SSE) → enter the server URL

Then start working in your project directory:

goose        # or: goose session

For a fully local, no-API-cost run, choose an Ollama provider in the configure step and pick a model you've pulled; goose will drive it exactly like a hosted one.

What it costs#

The agent is free and open source, with no paid tier. Your only bill is the model: goose is bring-your-own-key, so you pay your provider's token rate — or nothing, if you run a local model through Ollama. That's the trade against a bundled single-vendor subscription. You manage the model spend yourself; in exchange, no part of your workflow depends on one company's price list or roadmap. (If you're weighing that trade-off against a hosted terminal agent, we did the side-by-side in OpenCode vs. Claude Code — the same portability logic applies.)

Why "a Linux Foundation project" is the real headline#

goose isn't just another open-source repo from a big company. In late 2025 Block donated it to the Agentic AI Foundation (AAIF) at the Linux Foundation, making it one of three anchor projects there alongside Anthropic's MCP and OpenAI's AGENTS.md (Linux Foundation). For a founder deciding whether to build a workflow on top of goose, that changes the risk calculus: the usual worry about a vendor's open-source project — what if they relicense it, monetize it, or walk away? — is retired when the trademark and governance sit with a neutral foundation, the same one that now stewards MCP. We walked through exactly what that consolidation covers, and what it pointedly doesn't, in Who Controls MCP Now?.

The honest catch#

Three things to go in with your eyes open.

  1. You supply the model. Bring-your-own-key is the whole point, but it's still a setup step and a bill you own. Budget for the tokens, or run local.
  2. An on-machine agent is powerful because it can act — which is exactly why it's risky. goose can run shell commands and, with the right extension, control your computer. Point it at a sandbox or a scratch checkout first, and read what an extension is allowed to do before you enable it. Autonomy you don't supervise on a machine you care about is how a good tool becomes a bad afternoon.
  3. BYOK plus MCP is more configuration than a hosted app. The reward is a local-first, vendor-neutral agent that a cloud product structurally can't match. The cost is ten minutes and a willingness to live in a config wizard.

The founder read#

goose is the clearest expression yet of a bet a lot of builders are making in 2026: that the durable layer isn't the model or the vendor's cloud, but an open agent runtime that owns neither. If you want an autonomous coding-and-ops agent that runs on your hardware, swaps models freely, speaks the same MCP that the rest of the ecosystem now standardizes on, and can't be pulled out from under you by a pricing change, goose is worth the ten-minute setup. Start it against a scratch repo, give it a local model, and see how far a free, on-machine agent gets before you've spent a cent.