The most interesting proof point for Goose is not its 51,000+ GitHub stars. It's that Block's enterprise risk management team — not engineers, not a product squad — built an entire self-service automation system with it. Weeks of manual work compressed into hours. No Q2 roadmap, no ticket queue, no waiting for IT. That's the premise Goose is running on: an AI agent powerful enough for developers but accessible enough that a risk analyst or in-house counsel can actually use it.
Goose is built by Block — the company behind Square, Cash App, and TIDAL — under Apache 2.0 license. It's not a side experiment. Block reports saving over 100,000 hours per week across the company, with the non-technical teams logging the biggest per-person gains: 20–25% of manual hours gone, compressing month-long processes into days.
At a glance
| Fact | Value |
|---|---|
| Where it lives | github.com/block/goose |
| Popularity | 51,300 stars on GitHub (observed 2026-07-19) |
| License | Apache 2.0 — free for personal, commercial, and enterprise use |
| Maintained? | Yes — v1.43.0 shipped July 14, 2026; 5,098 commits, 143 releases |
| Install path | Desktop app (macOS/Linux/Windows), command-line tool, or embeddable API |
| Works with | 15+ AI model providers: Anthropic, OpenAI, Google, Ollama, Azure, Bedrock, and more |
| Setup time | ~5 min for the desktop app; ~10 min for the command-line tool with provider config |
| Cost | Free and open-source; you pay your own AI model API costs |
What Goose actually is
Goose is a general-purpose AI agent that runs locally on your machine — as a native desktop app, a command-line tool, or an API you can embed elsewhere. You describe a task in plain language; Goose plans and executes it, calling tools, reading files, running commands, and iterating until the work is done. It's not a chatbot with a few tools bolted on. It's an agent loop: think, act, observe, repeat.
The project is now governed under the Agentic AI Foundation (AAIF) at the Linux Foundation, which means it's not a Block product that could be sunset or relicensed at will — it's a foundation-stewarded open standard. That's an unusual governance choice for a corporate-originated project and it matters for anyone evaluating long-term adoption.
The reason Goose works across skill levels is that it externalizes complexity into extensions rather than requiring users to configure pipelines. You install the tool, connect a provider, and describe what you want. The agent handles the plumbing.
What ships in the repo
The core runtime is written in Rust — a programming language known for speed and low memory use — which keeps it fast and portable. On top of that:
- Extensions via MCP — Goose connects to 70+ extensions through the Model Context Protocol (MCP), an open standard for plugging tools into AI agents. Databases, GitHub, Google Drive, web browsers, APIs — each one is an MCP server that Goose can call. If an extension exists for a service you use, installation is usually one step inside the app.
- Recipes — Reusable saved workflows that package extensions, prompts, and settings together. A recipe for "weekly contract review prep" runs the same way every time, from any machine, by anyone on the team. Shareable via URL.
- Parallel task delegation — Goose can break a large task into parallel subtasks and delegate them to child agents, reassembling results when they finish.
- Prompt injection detection — built-in security review mode that flags adversarial instructions embedded in content the agent reads.
- 15+ AI model providers — swap between Anthropic Claude, OpenAI GPT-4o, Google Gemini, Ollama (local models, no API key required), Azure, Bedrock, Groq, Mistral, and others from the Settings panel. The docs note Goose currently works best with Claude 4 models.
- Desktop app + command-line tool + API — all three interfaces run the same agent core, so a recipe authored in the desktop app works identically in an automated server pipeline.
Why this matters for legal, risk, and ops teams
The standard story about AI agents is that they save developers time on code. Goose has that story too, but the more interesting data point from Block's deployment is what happened to the people who don't write code.
Block's enterprise risk management team built a self-service system entirely in Goose — no engineering involvement. Their process had involved pulling data from multiple internal systems, cross-referencing records, and generating reports on a recurring cycle. Each cycle took weeks. Goose collapsed it to hours by reading the relevant sources via extensions, applying the team's own review logic (described in plain language), and producing the output in the format they needed.
The pattern generalizes. Legal teams doing contract review, ops teams reconciling records, analysts pulling structured reports from databases — these are all tasks Goose can take on once someone connects the right extensions. The Recipes feature is what makes it repeatable: the analyst who figured out the workflow can share it as a saved file, and everyone else on the team runs it without having to understand what's under the hood.
The 20–25% manual hour reduction Block reports for non-technical roles is consistent with what you'd expect when you automate the "pull this, cross-reference that, format it" portion of knowledge work. The portion that remains is judgment — reviewing outputs, making decisions — which is where humans stay in the loop.
Where it fits
Goose occupies a different position from most open-source agents because it's a finished product, not a framework.
- OpenHands (formerly OpenDevin) — the closest architectural sibling, with a strong software-engineering focus. Better for code-heavy workflows; less emphasis on the non-technical-user path that Goose has invested in.
- Hermes — a self-hosted personal automation runtime oriented around scheduled tasks, gateways (Telegram, Slack, etc.), and markdown-based skills. Better fit for always-on personal automation; less suited to the interactive "here's a task, do it now" pattern.
- Cline — a coding agent that lives inside VS Code (Visual Studio Code). Excellent for developers who want agent capabilities inside their editor; not aimed at non-technical users at all.
- AutoGen — Microsoft's multi-agent framework. You write code to define agents. More flexible, more complex, requires a developer to set up. Goose is a product; AutoGen is a toolkit.
If the person doing the setup is a developer and the people benefiting include non-technical colleagues, Goose's combination of a polished desktop app, Recipes, and MCP extensions is hard to beat among open-source options.
Verdict
Install. The Block deployment data is credible because it comes from the team that built the tool and had every incentive to make it work. The 100,000+ hours/week figure is aggregate, but the specifics — risk management teams replacing multi-week cycles, non-technical users building their own workflows — are the kind of concrete evidence that's hard to manufacture. The Apache 2.0 open-source license and Linux Foundation governance remove the usual open-source adoption risks. The 15+ provider support means you're not locked into a single AI model vendor.
The honest caveat is that "works best with Claude 4 models" from the docs means your mileage with weaker models may vary for complex multi-step tasks. The local Ollama path exists and has a following, but for production use at a team level, you'll want a capable cloud model. Budget accordingly.
For your agent to install this
You can skip this section — it's the install details your AI agent needs. If you're using Cowork, Claude Code, ChatGPT Work, Codex, or Hermes, say "install Goose for me" and it will read the tables below.
System / OS requirements
| Requirement | Detail |
|---|---|
| Operating system | macOS (Intel + Apple Silicon), Linux (DEB/RPM/Flatpak), Windows |
| macOS M3 note | Ensure the ~/.config directory has read/write permissions before install |
| Windows shell | Git Bash or PowerShell required for the command-line tool |
| Architecture | Standard (Intel/AMD) and ARM chips supported |
API keys
Goose requires at least one AI model provider key to function. Local providers (Ollama, LM Studio) require no key.
| Provider | Where to configure | Where to get a key |
|---|---|---|
| Anthropic (Claude) | Settings → Models in the app, or set the ANTHROPIC_API_KEY environment variable | console.anthropic.com |
| OpenAI | Settings → Models in the app, or set the OPENAI_API_KEY environment variable | platform.openai.com |
| Google Gemini | Settings → Models in the app | aistudio.google.com |
| Amazon Bedrock | AWS credentials must be configured before first run | AWS IAM console |
| Ollama (local) | None — runs entirely offline, no key needed | ollama.com |
Install commands
macOS — Desktop app (Homebrew):
brew install --cask block-goose
macOS — CLI (Homebrew):
brew install block-goose-cli
macOS / Linux / Windows Git Bash — CLI (curl):
curl -fsSL https://github.com/aaif-goose/goose/releases/download/stable/download_cli.sh | bash
Windows — CLI (PowerShell):
Invoke-WebRequest -Uri "https://raw.githubusercontent.com/aaif-goose/goose/main/download_cli.ps1" -OutFile "download_cli.ps1"; .\download_cli.ps1
Linux — Desktop app: Download the installer for your distribution (DEB for Ubuntu/Debian, RPM for RHEL/Fedora, or universal Flatpak) from the Goose releases page.
First-run
Desktop: Launch the app, complete Quick Setup with your API key or provider login, then type a task. Done.
CLI: Navigate to a working directory and run:
goose session
On first run, the setup wizard prompts for your provider and API key. To update your provider later, run goose configure again, or use Settings → Models in the desktop app.
Extensions
Browse and install MCP extensions from inside the app (Extensions tab). For custom MCP servers, add them via Settings → Extensions with the server URL and any required credentials.