Goose
Most local AI agents stop at code — useful for a sprint, irrelevant the moment you need the same agent to pull from a database, file a GitHub issue, and summarize a research doc in the same run. Goose is a general-purpose agent built to do all of that on your machine, without handing your data to a hosted SaaS platform.
Get This Tool
Pricing
- Model
- Free
Summary
Goose runs as a desktop app, CLI, or embeddable API — built in Rust, so the performance profile is consistent across macOS, Linux, and Windows without a runtime you have to manage separately. The extension system connects to 70+ tools via the Model Context Protocol, meaning a workflow touching GitHub, Google Drive, and a database isn't stitched together with custom glue code — the standard handles the handoff. Recipes let you capture multi-step workflows as YAML configs and share them across a team or drop them into CI. Where the architecture shows its limits: complex conditional branching inside recipes is not the same as writing that logic in code, and teams building workflows that require dynamic decision trees at depth report dropping into Python extensions to compensate — at which point they are maintaining two systems. Community support is Discord-first; the project offers no paid tier, so production SLA expectations need to be reset before an org-wide rollout.
Bottom line: Goose earns its place on any developer's machine who needs a local, extensible agent for code, research, and automation workflows — but teams whose pipelines depend on complex branching logic or require guaranteed support response times will hit the ceiling of what YAML recipes and a Discord community can hold.
We installed and ran it
- How we installed it
- Vendor one-line install script
- Docker image size on disk
- 0.71 GB
- Model we used
- qwen2.5:3b via Ollama
- Agent tasks passed
- 5 of 9
- Fixed prompt sent with every model call
- ~1,150 tokens
- Outside hosts it tried to reach (we blocked them)
- models.dev
| Task | Passed | Median time |
|---|---|---|
| Create a file with given text | 3 / 3 | 10.5 s |
| Read a report and write a 2-sentence summary | 1 / 3 | 33.1 s |
| Count the data rows in a CSV with a shell command | 1 / 3 | 15.1 s |
- Every failure was a model mistake (reading a .txt file as an image, counting the CSV header row). Goose itself exited cleanly on all 9 runs.
- It looked up models.dev on every run. We blocked it and goose kept working.
Measured against Hermes Agent
| Measured | Goose | Hermes Agent |
|---|---|---|
| Tasks passed with qwen2.5:3b (of 9) | 5 | 0 |
| Fixed prompt sent with every model call (tokens) | 1,150 | 11,500 |
| Docker image size on disk (GB) | 0.71 | 4.17 |
| Outside hosts it tried to reach | 1 | 5 |
Same model (qwen2.5:3b on 3 CPU cores), same three tasks, three runs each, graded on the files left behind. Ollama capped the context at 32,768 tokens for both, below the 64K Hermes' docs ask for, and a 3B model is far below the model size Hermes asks for, so read the task score as 'which agent copes with a small local model', not overall quality.
Test machine: 8-vCPU AMD EPYC 9354P cloud VM, each test limited to 3 cores and 10 GB RAM, no GPU, no internet (isolated Docker network). Times in seconds are from this CPU-only machine; a desktop with a GPU will be much faster. The VM is shared, so text-generation speed is shown only as a ratio between tools run back to back, not as tokens per second. Docker image size is the on-disk size from docker image ls for every tool. How we test · raw data
Pros
- Runs fully on your machine with no required hosted dependency, so proprietary code and internal data never leave your infrastructure unless you route them to an external LLM — which you control.
- YAML-defined Recipes capture entire multi-step workflows as portable configs, so a workflow one engineer builds on their laptop can run unchanged in CI or be handed to the rest of the team without re-explanation.
- Connects to 70+ extensions via the Model Context Protocol open standard, which means swapping in a new database, API, or browser tool doesn't require rewriting the agent's integration layer.
- Provider-agnostic LLM routing across 15+ providers, so switching from OpenAI to Ollama when API costs spike — or to a local model for sensitive data — is a configuration change, not an architecture change.
- Subagents handle tasks in parallel, so a workflow that would otherwise queue code review behind research behind file processing can run all three at once without tangling the main session context.
Cons
- Complex conditional branching inside Recipes — logic that depends on what a previous step returned and routes differently based on that — is not a first-class YAML primitive. Teams building workflows with more than two or three decision branches add a Python extension layer to handle the logic, which means they are now maintaining the agent config and the extension code as separate systems.
- There is no paid support tier, no SLA, and no vendor escalation path. Production incidents land in Discord. Engineering teams at organizations with uptime commitments who discover this after deployment replace Goose with a managed platform — typically one that offers a hosted agent runtime with contractual support — and keep Goose only for local developer tooling.
- The desktop UI's MCP app rendering (buttons, forms, visualizations inside extensions) is tied to the Goose Desktop client. Teams embedding Goose via the API for headless or server-side automation get none of that interactive surface, so UI-dependent extensions have to be redesigned or abandoned for non-desktop deployments.
About
- Platforms
- macOS, Linux, Windows
- API Available
- Yes
- Self-Hosted
- Yes
- Last Updated
- June 20, 2026
Best For
Who it's for
- Developers needing local AI agents
- Teams building extensible agent workflows
- Users integrating multiple LLM providers and tools
What it does well
- Automate code workflows and testing
- Research and data analysis tasks
- Execute multi-step automation with extensions
- Run reusable YAML-defined recipes in CI or teams
Integrations
Frequently Asked Questions
- Is Goose free?
- Yes — Goose is fully free to use. There is no paid tier.
- Is Goose open source?
- Yes. Goose is open source.
- Does Goose have an API?
- Yes. Goose exposes a developer API. See the official documentation at https://goose-docs.ai for details.
- Can I self-host Goose?
- Yes. Goose supports self-hosting on your own infrastructure.
- When was Goose released?
- Goose was first released in 2025.
- What platforms does Goose support?
- Goose is available on: macOS, Linux, Windows.
People also compared
Curated lists that include this category
Goose is a general-purpose AI agent that runs natively on your machine — no hosted dependency, no data leaving your infrastructure unless you configure an external LLM provider. The core workflow is a loop: you give it a task, it uses available extensions to take actions (run code, query a database, search the web, interact with GitHub), checks what it got back, and continues until the task is done. You interact through a desktop GUI, a full CLI, or an API that lets you embed the agent into your own tooling. Built in Rust, the goose docs describe it as designed for performance and portability across macOS, Linux, and Windows.
The differentiating architecture is the Recipe system combined with deep Model Context Protocol integration. Recipes are portable YAML configs that capture a complete workflow — extensions to load, parameters to accept, instructions to follow, and subrecipes to call. You write one once, share it with your team, run it in CI, or publish it to the community. The MCP integration gives access to 70+ documented extensions covering databases, browsers, APIs, GitHub, Google Drive, and more. Subagents let you spawn parallel workers — code review in one thread, research in another — without clogging the main conversation context. Extensions can also render interactive UIs directly inside the desktop app, so agent-powered tools can surface buttons, forms, and visualizations without a separate frontend.
Goose fits best when the work is exploratory or task-driven and the team values local execution and open standards over a managed platform. It supports 15+ LLM providers — Anthropic, OpenAI, Google, Ollama, Azure, Bedrock, OpenRouter — and the goose docs say it can use existing Claude, ChatGPT, or Gemini subscriptions via the Agent Client Protocol. Where it does not fit: teams that need deterministic, auditable decision trees at scale will find YAML recipes underpowered and will end up extending with code. There is no paid tier and no hosted support contract; the governance sits with the Agentic AI Foundation under the Linux Foundation, which keeps the project vendor-neutral but means production support is community-mediated.
Goose operates as an ACP server, meaning it connects directly from editors like Zed, JetBrains, and VS Code, and can treat Claude Code and Codex as upstream providers. Security features the goose docs describe include prompt injection detection, tool permission controls, sandbox mode, and an adversary reviewer that watches for unsafe actions during execution — relevant for teams nervous about giving an autonomous agent write access to production tooling.
Contribute
- Work on Goose? Claim this listing.
- Embed a badge for your README or site.
Sign in to rate this tool or suggest an edit.