Goose: The Open-Source AI Agent That Block Built and the Linux Foundation Now Runs

Every AI agent framework has a story. Most of them are the same story: raised on a mountain of venture capital, marketed aggressively, built to impress in demos, and quietly abandoned when the runway runs out or the founders get acqui-hired. Goose is not that story.

Goose started at Block — Square's parent company — as an internal tool. Block engineers were spending too much time on maintenance and repetitive engineering tasks. The CTO, Dhanji Prasanna, wanted an agent that could actually operate in a development environment, not just suggest code. So the team built one. They used it internally. They watched it work. And then they open-sourced it.

That sequence — build internally, validate, then release — is rare enough to be notable. But what happened next is what makes Goose worth paying attention to right now.

The Linux Foundation Took It Over

In late 2025, Block donated both Goose and the Model Context Protocol to the Agentic AI Foundation, a directed fund under the Linux Foundation. Anthropic had already donated MCP to the same foundation. This means Goose's extensions are, by design, MCP servers — and MCP servers work with Goose. The ecosystem is self-reinforcing.

This is not a hobby project with a Apache license stapled on. The governance structure is documented on GitHub. The release artifacts are signed. The project has CI/CD pipelines, custom distributions guidance, and a Discord community that's been growing consistently since the donation. When a project moves from a corporate repo to a neutral foundation, it either accelerates or stagnates. Goose has accelerated.

What Goose Actually Does

Goose is a general-purpose AI agent that runs on your machine. Not just for code. Not just for terminal tasks. It can handle research, writing, data analysis, workflow automation — anything you can describe and give it access to.

The architecture is worth understanding because it's different from the typical "agent framework" that's just a prompt wrapper and a few tool calls.

Goose is built in Rust. The core agent is a native desktop app for macOS, Linux, and Windows — full GUI, persistent session state, extension management. It also ships as a full CLI for terminal workflows. And it exposes an API so you can embed it anywhere. The desktop, CLI, and API share all configurations and extension settings. You can switch between interfaces without re-configuring anything.

On the model side: Goose works with 15+ providers. Anthropic, OpenAI, Google, Ollama, OpenRouter, Azure, Bedrock — and more via ACP (Agent Context Protocol), which lets you use existing Claude, ChatGPT, or Gemini subscriptions without additional API setup. The documentation notes explicitly that Goose works best with Claude 4 models, which tracks with the tool-calling intensity of agentic workflows.

The extension system is where it gets interesting. Extensions are MCP servers. Connect to 70+ extensions via the Model Context Protocol open standard. The MCP ecosystem was Anthropic's gift to the industry, and Goose is one of the cleanest implementations of it as a first-class citizen. If a tool has an MCP server, Goose can use it. If you want to build a new capability, you write an MCP server and Goose can use it.

The Desktop Experience vs. The CLI Experience

Most open-source agents are CLI-only. That's fine for developers who live in terminals. It's a barrier for everyone else. Goose's desktop app changes the access threshold.

The setup flow is straightforward: download the app (or install via Homebrew), pick your LLM provider, and start a session. The welcome screen offers quick-setup options: API key, ChatGPT subscription, Agent Router (Tetrate), or OpenRouter. First-time configuration takes under five minutes if you have an API key ready.

The CLI is the same agent, no GUI. Install with a curl script, set your provider via environment variable, and you're in a session. For CI/CD use cases, you can pin a specific version with GOOSE_VERSION to make installs reproducible — no surprising breakage when a new stable release drops mid-pipeline.

The shared configuration between both interfaces is actually useful. Configure extensions once, they're available in both. Configure your provider once, same. This sounds trivial but most agent tools make you pick a lane.

The MCP Connection That Matters

Here's why the MCP donation matters more than the average developer notices: MCP is becoming the USB-C of AI tool connectivity.

Anthropic built MCP as a standardized way to connect AI agents to the systems where data lives — content repositories, business tools, development environments. The analogy USB-C is apt: instead of every agent building custom integrations for every tool, you build one MCP server and any MCP-compatible agent can use it.

Goose's extensions are MCP servers. The 70+ extensions available at launch cover the usual suspects — GitHub, file systems, web search — but the number is growing as the MCP ecosystem expands. More importantly, because MCP is an open standard at the Linux Foundation, the extension ecosystem isn't controlled by Goose's maintainers. Anyone can build one.

The practical implication: if you're building with Goose, you're not locked into Goose's roadmap for integrations. You can build an MCP server for your internal tools and plug it into Goose. Or into any other MCP-compatible agent. The interoperability is real, not marketing copy.

Where It Falls Short

No framework is complete, and Goose has honest limitations worth knowing about.

Goose relies heavily on tool calling. The documentation states this plainly — it works best with Claude 4 models, and models without strong tool-calling capabilities will underperform. If you're running local models via Ollama that don't have robust tool-calling fine-tuning, you'll feel the gap.

The Rust implementation is a strength for performance and distribution, but it means the extension ecosystem has a different character than Python-based agent frameworks. Most AI tooling is Python-first, and some useful libraries don't have Rust equivalents. The MCP bridge handles most of this, but you may encounter cases where a tool you want isn't available yet.

The agentic memory is session-scoped by default. Long-running multi-session tasks with persistent context across sessions require some manual configuration. This is common among agent frameworks and not unique to Goose, but it's worth knowing before you build a complex workflow.

Production hardening is ongoing. The project moves fast and the desktop app occasionally has permission quirks on macOS M3 chips that require manual config directory fixes. These are documented in the Known Issues guide, but they indicate a project that's moving quickly and occasionally outrunning its documentation.

The Comparison That Makes Sense

LangChain Agents is the kitchen-sink approach — everything included, everything configurable, enormous flexibility with enormous complexity. Goose is the opinionated approach — sensible defaults, clear architecture, MCP as the integration layer rather than a custom plugin system.

If you're building research prototypes and want maximum flexibility, LangChain is probably what you want. If you're building something that needs to run reliably, be maintainable, and integrate with existing tools via a standard protocol, Goose is worth a serious look.

The other meaningful comparison: Goose vs. building your own agent layer from scratch. Custom agent implementations are usually under-built. They handle the happy path well and fall apart on edge cases, rate limiting, error recovery, and context management. Goose gives you a production-tested agent loop with tool calling, session management, and extension loading as first-class features. The customization comes from extensions and configuration, not from reimplementing the agent loop.

The Takeaway

Goose is not the loudest AI agent framework in the room. It doesn't have the marketing budget of the hyperscalers or the hype cycle of the latest foundation model release. What it has is a clean architecture, a real production use case at a real company, a neutral foundation backing, and an open standard integration layer that makes the whole thing more valuable than the sum of its parts.

If you're evaluating AI agent frameworks in 2026, it deserves a spot in your shortlist. The Rust implementation is fast, the MCP ecosystem is growing, and the fact that the Linux Foundation is holding the governance keys means this isn't going anywhere. The next time you're building an agentic workflow and reaching for LangChain out of habit, spend an afternoon with Goose instead. You might be surprised what a difference an opinionated architecture makes.

Goose is available at goose-docs.ai and on GitHub. Apache License 2.0. Built with Rust. Governed by the Agentic AI Foundation at the Linux Foundation. MCP-compatible extensions available at launch: 70+.