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
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
FREE — Open 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