mrkeyoor.com_
Wed 16 Sept 05:28 UTC
AI Toolsevaluationupdated 27 Aug 2026

goose review

Goose is a local AI agent with a desktop app, command-line interface, and embeddable API for editing code, running tools, research, and repeatable workflows. The original `block/goose` address now resolves to `aaif-goose/goose`, where the project supports hosted and local model providers plus extensions through MCP.

+283stars / 7d
Verdict

Our Goose build and test commands each exceeded 900 seconds, so the packaged app is easier to recommend than source contribution on a 3-CPU machine. Use Goose when provider choice and MCP extensions are worth a powerful local agent, but approve its commands and inspect every shared recipe. A narrower coding agent is a better fit when non-code workflows and 70-plus extension options would add risk without helping the job.

We ran it

Lab card: what happened when we ran gooseScreenshot of goose (goose-docs.ai)
Install✓ · 46s1281 packages
Build✗ timed out · 900s
Tests✗ timed out · 900sran, no count parsed
Repo2365 files~384,063 lines of source · 360.4 MB · 41 CI workflows · Dockerfile

Answers from our run

Does goose build from source?

Dependencies installed in 46 seconds (1281 packages), and the build failed. We cloned commit 9a4e043 into a clean Debian container with 3 CPUs and no project-specific setup.

Do goose's tests pass?

We could not finish them: the suite was still running after 15 minutes in our container.

Who should not use goose?

People who run recipes from strangers without inspection: open issue 10325 demonstrates a shared recipe executing shell commands through extension and retry fields without a CLI consent prompt in version 1.37.0.

What are the alternatives to goose?

Codex, Gemini CLI, OpenHands. Our Goose build and test commands each exceeded 900 seconds, so the packaged app is easier to recommend than source contribution on a 3-CPU machine.

Setup3/5Prebuilt installs are clear; source build exceeded 900 seconds
Docs4/5Good install and provider coverage, with safety details spread out
Community5/553,544 stars and active issue work on August 27, 2026
Maturity3/5Version 1.47.0 is active; source checks and recipe safety need care

Discussed on

  1. hnGoose: An open-source, extensible AI agent that goes beyond code suggestions249 points
  2. hnShow HN: Red Goose – Convert your website to mobile app86 points
  3. hnGoose – an open-source, extensible AI agent that goes beyond code suggestions40 points
  4. hnCodename Goose19 points
  5. hnCodename Goose11 points

Who it’s for

Developers who want an agent to inspect files, edit code, and run project commands from a desktop or terminal.
Teams that need a choice of model providers instead of one vendor account.
MCP users assembling agent access to development tools and business systems.
Organizations willing to review permissions, recipes, extensions, and generated actions before execution.

Who it’s NOT for

People who run recipes from strangers without inspection: open issue 10325 demonstrates a shared recipe executing shell commands through extension and retry fields without a CLI consent prompt in version 1.37.0.
Source contributors who need quick feedback on modest hardware: both our build and test commands hit the 900-second cap.
Workflows that assume a cheap or small model will call tools reliably: the provider guide says Goose relies heavily on tool calling and currently works best with Claude 4 models.
Desktop users depending on Node wrapper exit codes and relative paths: issue 11586 reports version 1.47.0 changing the working directory and returning 0 after a child exits 37.
Long autonomous tool loops that must compact before context exhaustion: issue 11072 documents compaction being checked only at turn boundaries.

Setup reality

Our sandbox installed 1,281 Rust packages in 46 seconds. The build hit the 900-second limit without completing, and the tests also timed out at 900 seconds. Their log tail still showed tracing and title-generation tests passing, but no final count or suite result was produced.

The prebuilt desktop and CLI routes are simpler. A useful session needs either provider credentials, a supported subscription login, or a running local model server. MCP extensions add their own executables, OAuth flows, tokens, files, and permissions.

Windows CLI installation needs Git Bash, MSYS2, or PowerShell. Model quality matters because Goose depends on tool calls. Shared recipes can start local processes, so source and command review belong in setup rather than after an incident.

One agent spans desktop, terminal, and an API

Goose is a local agent rather than a code-completion plug-in. It can edit files, execute commands, research a topic, analyze data, and run saved recipes from a native desktop app or terminal. An API lets other software embed the same agent loop. The project supports more than 15 model providers and over 70 MCP extensions according to its README, giving one installation access to cloud accounts, local model servers, and external tools.

That breadth is the reason to choose Goose and the first reason to slow down. A coding request can cross the model provider, agent history, filesystem, shell, and one or more MCP servers before it completes. Each layer carries separate credentials and failure modes. The UI can make this feel like one conversation, but an operator should still decide which directories, commands, network services, and extensions the session may reach. A good model does not replace those boundaries.

The packaged install avoids a 360.4 MB source tree

Desktop builds are available for macOS, Linux, and Windows. The CLI has a download script, Homebrew packages, and Windows routes through Git Bash, MSYS2, or PowerShell. First use configures a model provider. That may mean an API key, browser login for a supported subscription, cloud credentials already present in the environment, or a local server such as Ollama with a model downloaded and running.

Source contributors face a much larger project. commit 9a4e043 contained 2,365 files, roughly 384,063 source lines, and occupied 360.4 MB before the Rust dependency install. Our scan found 41 CI workflow files and a Dockerfile, but no separate tests directory. The install resolved 1,281 packages. That scale is consistent with a cross-platform desktop app, CLI, API, provider layer, and extension system, but it demands more patience than the binary installation path.

What happened when we ran it

Our sandbox installed 1,281 Rust packages in 46 seconds. The build then reached our 900-second limit and was stopped without a success result. Tests also reached 900 seconds without finishing. The run used a fresh unprivileged Debian container with 3 CPUs and 12 GB of RAM at commit 9a4e043. We did not record a completed build or test suite for this checkout.

The final test lines were active rather than an immediate crash. They showed several Langfuse tracing tests passing, along with observation-layer tests and title-generation cases. There was no final total, failure count, or summary before the timeout, so those lines cannot be converted into a pass rate. The useful finding is simple: Goose's available checks did not fit inside 15 minutes per build and test step on our box. Contributors should expect a long first cycle or use more capable hardware and narrower crate-level commands.

Shared recipes can start commands before model work

Recipes package prompts, activities, retry rules, and extensions so a workflow can be reused or shared. That is useful for repeatable development and operational tasks. It also gives the recipe authority outside natural-language instructions. A stdio MCP extension names a local command and arguments, while a retry check can run a shell command to decide whether work succeeded. These fields should be treated as executable code.

Open issue 10325 reports that version 1.37.0 ran a recipe's stdio extension command without a CLI consent prompt or command preview. The reporter also found that the recipe security scan inspected hidden Unicode in instructions, prompts, and activities, but did not inspect extension commands or retry shell checks. The proof wrote command output as the current user even though the MCP handshake later failed. The issue remained open and was updated on August 26, 2026. Inspect local files and resolved recipe content before every first run.

Long tool loops can exhaust context inside one turn

Goose supports several provider families, though the official provider guide says tool calling is central and that Claude 4 models currently work best. Compatibility is therefore more demanding than accepting chat text. A model must return the expected tool structure, handle results, and continue coherently. Provider credentials differ too: Bedrock and SageMaker require preconfigured cloud state, subscription providers use login flows, and local providers require a separate running model service.

Context handling has a current edge case. Issue 11072 reproduces auto-compaction only being checked at user-turn boundaries. In the reported version 1.45.0 session, one tool-heavy turn grew from 17,189 input tokens to the 49,152-token ceiling without another compaction check, leaving only 32 output tokens. The issue concerns one provider setup, yet the mechanism matters to any autonomous task that makes many tool calls before returning control. Set budgets and require checkpoints outside the agent rather than assuming compaction will always rescue a run.

Version 1.47.0 is active, with sharp desktop edges

The canonical GitHub repository now reports the name aaif-goose/goose; the requested block/goose URL redirects there. GitHub recorded 53,544 stars and 195 combined issues and pull requests, with code pushed on August 27, 2026. Release v1.47.0 arrived on August 21 with OAuth, provider, recipe, context, file-read, and session fixes. This is an actively changing agent, not an abandoned experiment.

Active does not mean every desktop wrapper is settled. Issue 11586 reports Goose Desktop 1.47.0 changing Node and npx commands to the MCP Hermit directory, so project-relative paths resolve incorrectly. Its reproduction also exits a Node child with status 37 while the wrapper logs success and returns 0. For an agent that judges work by command results, masking failure is serious. Verify working directories and exit propagation in any recipe that depends on bundled launchers.

Goose is worth testing when one local agent must cross coding and general workflows, especially across several providers or MCP systems. The 900-second source timeouts and open execution concerns keep it from being a casual recommendation. Start with a prebuilt release, a disposable repository, a narrow extension list, and explicit approval for commands. Promote it only after the exact provider, recipe, and tool chain reports failures honestly.

Alternatives

ProjectWhat it isPick it when
Codex gh↗A terminal coding agent tied closely to OpenAI models and developer workflows.pick this instead when the job is mainly software development and an OpenAI-centered tool is acceptable.
Gemini CLI gh↗Google's terminal agent for coding, research, and tool use.pick this instead when Gemini integration and a terminal-first workflow matter more than Goose's provider range.
OpenHands gh↗A development-agent platform with sandboxed execution and a web interface.pick this instead when isolated coding workspaces and team deployment matter more than a native personal agent.

What people are saying

  1. [github-trending] aaif-goose/goose

Sources

  1. Goose README
  2. Goose installation guide
  3. Goose provider guide
  4. Goose v1.47.0 release
  5. Goose issue 10325: recipe command execution
  6. Goose issue 11072: in-turn context exhaustion
  7. Goose issue 11586: desktop Node launcher

More ai tools reviews

Concat · DLSS5-Feeder · Concat · LocalMiniDrama · agents-towards-production · Marinara-Engine · the whole board →