Delv
General AssistantActive· 6dby Block4.1

Goose

Open-source extensible AI agent from Block that runs on your machine for coding, research, writing and automation via MCP.

B
Safety & Trust

Delv Safety Grade: B

Score 72/100 · assessed 2026-04-18

Maintainer85
Permissions40
Supply chain75
Transparency90
Incidents100

Goose is Block's open-source AI agent that runs locally with extensive system access for coding and automation tasks. Block (formerly Square) provides strong organisational backing with active development and comprehensive documentation. The agent architecture uses MCP for extensibility, which is well-documented and transparent. However, as an autonomous agent designed for coding and system tasks, Goose requires broad permissions including filesystem write access, shell execution, and network connectivity. The local-first design means your machine becomes the execution environment with minimal sandboxing. Supply chain is reasonable via pip installation with standard Python packaging, though dependency pinning could be tighter. No known security incidents. The trade-off is clear: powerful automation capabilities in exchange for significant system access. Suitable for developers comfortable with local AI agents having broad permissions.

Green flags

  • Backed by Block (Square), established fintech company with security track record
  • Fully open source with active GitHub repo and transparent development
  • Comprehensive documentation and clear architecture using MCP standard
  • Local-first design keeps data on your machine rather than cloud services
  • Active community and regular updates visible in commit history

Red flags

  • Autonomous agent with shell execution capabilities on local machine
  • Filesystem write access across user directories without strict sandboxing
  • Network outbound access for API calls and external integrations
  • Requires API keys stored in environment variables for LLM providers

Permissions requested

Read filesWrite filesShell executeOutbound networkRead envAccess secretsExternal LLM call
Assessed by Delv Editorial using public metadata. Grades are advisory and update as the ecosystem changes. They do not replace your own review of permissions and code before granting an agent access to sensitive systems.

Pricing

FREEOpen source

Platforms

desktopcli

Review

Goose is Block's answer to the question: what if your AI agent lived on your machine instead of someone else's cloud? It's a command-line agent that plans multi-step tasks, executes them, and iterates when things go wrong. The autonomy shows up in how it chains actions: ask it to refactor a codebase, and it will scan files, propose changes, run tests, fix breakages, and commit the result without you babysitting each step. I've used it for cleaning up legacy Python projects. Point it at a directory, describe the refactor, and it will work through files methodically. It caught edge cases I would have missed and fixed its own mistakes when tests failed. The local execution matters: it reads your filesystem, runs shell commands, and respects your environment without uploading your code to a third party. For anyone working with proprietary codebases, that's the entire point. The MCP integration is the clever bit. Goose doesn't ship with every possible capability baked in. Instead, it connects to MCP servers for specific tasks: filesystem access, database queries, API calls. You configure which servers it can use, and it figures out when to invoke them. This makes it extensible without bloating the core agent. If you need it to interact with a new service, you add an MCP server rather than waiting for Block to ship an update. Where it stumbles: the command-line interface is spartan. No GUI, no progress visualisation beyond text logs. If a task goes off the rails, you're reading through terminal output to diagnose it. The planning is decent but not magical. On ambiguous tasks, it will pick a direction and commit rather than asking clarifying questions. I've had it refactor code in ways that were technically correct but missed the intent. Compared to Aider, Goose is broader but less polished for pure coding. Aider understands Git workflows and code context better. Goose tries to be a general assistant, which means it's competent at coding, data analysis, and automation but not the sharpest tool for any single job. The trade-off is flexibility: Goose will draft documents, query databases, and automate workflows in the same session. The open-source model is a double-edged sword. You can audit the code and run it offline, but you're also responsible for setup and troubleshooting. No support team, no polished onboarding. If you're comfortable with command-line tools and want an agent that stays on your machine, Goose delivers. If you want something that just works out of the box, look elsewhere.
Verdict

Best for developers who value local execution and extensibility over polish. If you need an agent that won't upload your code and you're willing to configure MCP servers, Goose is a solid choice. Skip it if you want a GUI or need hand-holding.

Good at

  • Runs entirely on your machine, no code leaves your environment
  • Extensible via MCP servers rather than waiting for vendor updates
  • Handles multi-step tasks with decent planning and error recovery
  • Open source, auditable, and free
  • Works across coding, data analysis, and automation in one agent

Watch out

  • Command-line only, no GUI or visual progress tracking
  • Planning can miss intent on ambiguous tasks
  • Setup and troubleshooting are your responsibility
  • Less specialised for pure coding than tools like Aider
  • Sparse documentation for advanced MCP configurations

Use cases

  • coding
  • data analysis
  • local automation