I've been looking for a free agent that doesn't feel like a compromise. OpenCode got close. Goose got closer. It's a free, open-source AI agent from Block, now governed by the Linux Foundation's Agentic AI Foundation, with 55,000 GitHub stars and a desktop app. I spent a week using it as my primary agent. Here's what happened.
What Goose actually is
Goose is a desktop app and CLI that does the same job as Claude Code: it reads your project, runs commands, edits files, and works through tasks step by step. You bring the model. Goose brings the harness. That's the entire value proposition, and it's a good one.
The software costs nothing. It's Apache-2.0 licensed with no paid tier. You can run it against local models (free, beyond your hardware), API keys (billed per token), or your existing Claude Code subscription through a bridge. The model is the cost. The agent is free.
That distinction matters more than it sounds. Most "free" coding agents are free the way a free puppy is free. The tool costs nothing, but the model costs everything, and the tool is useless without the model. Goose is honest about this. The review I read before trying it put it well: "free" does a lot of work in that sentence.
The thing that surprised me
The release cadence. Five releases in under four weeks. v1.50.0 on September 8, v1.53.0 on October 2. For an open-source project, that's aggressive. For a project that was recently transferred from Block to the Linux Foundation, it suggests the maintainers are serious about keeping it moving.
v1.53.0 added support for Opus 5.5, GPT-6-sol, GPT-6-luna, and a Meta Muse Code provider. That's a model list that would have been impressive for a commercial tool six months ago. For a free tool, it's unusual.
The desktop app is the other surprise. Most open-source agents are CLI-only. Goose has a desktop app, a CLI, and a web app. The desktop app is the one I used most, because I'm tired of terminal context switching. It's not as polished as Cursor, but it's usable, and it's free.
What it gets right
The model flexibility is the strongest feature. You can swap models mid-session. Start with a cheap local model for boilerplate, switch to a frontier model for the hard part, drop back to local for cleanup. That workflow is not possible in most commercial tools, and it's the reason I kept using Goose after the first week.
The local model support works. I ran it against a 7B model on my laptop for a day. The suggestions were mediocre, but they were private, free, and offline. For anything proprietary, that's the baseline. Goose clears it.
The context handling is good. It reads the project, understands the structure, and maintains context across a session. Not as deep as Claude Code, but close enough that I didn't feel like I was losing information.
The plugin system is worth mentioning. Goose has a plugin architecture that lets you extend it with custom tools and providers. It's not as mature as Claude Code's plugin ecosystem, but it's there, and it's growing. If you want to wire Goose into your own tooling, the extension points are documented and usable. That's more than most open-source agents offer.
Where it still frays
The setup is not zero-friction. You need to install Goose, configure a model provider, and understand which model you're pointing it at. The first hour is spent reading docs, not writing code. That's normal for open-source tools, but it's the gap between Goose and the commercial alternatives.
The desktop app has rough edges. I hit a bug where the file tree didn't refresh after an agent edit, and I had to restart the app to see the changes. That's the kind of thing that commercial tools handle silently and open-source tools handle with a GitHub issue. The issue was already filed, which tells you the maintainers are aware, but it's still there.
The model quality ceiling is real, same as every agent. Goose is only as good as the model behind it. Point it at a 7B local model and you get 7B-quality suggestions. Point it at Opus 5.5 and you get Opus 5.5 quality. The tool is the harness. The model is the engine. Don't blame the harness for the engine.
There is also the question of ecosystem. Claude Code has a plugin ecosystem, a marketplace, and a community of people building tools around it. Goose has a community, but it is smaller and newer. If you depend on third-party integrations, the commercial tool has more to offer. If you depend on the core agent loop, Goose is sufficient.
The honest comparison
I ran Goose and Claude Code side by side for a week on the same tasks. Here's what I found.
For straightforward tasks, refactors, boilerplate, and test generation, Goose with a good model is indistinguishable from Claude Code. The diffs are similar, the speed is similar, the quality is similar. The difference is the cost: Claude Code is $20 to $200 per month, Goose is free plus model costs.
For complex multi-file reasoning, Claude Code still wins. It has deeper context management, better handling of large codebases, and more reliable tool use. Goose is close, but "close" matters when you're debugging a production issue at 2 AM.
For local-only work, Goose wins outright. Claude Code requires a cloud connection. Goose can run fully offline with a local model. For proprietary code, that's not a feature, it's a requirement.
Who should use it
If you're already paying for Claude Code and you're happy with it, Goose won't convert you. The commercial tool is more polished, more reliable, and better integrated. You're paying for that, and it's worth it if your time is worth more than the subscription.
If you're a developer who wants to run an agent against a local model, or who wants to use multiple providers, or who doesn't want to pay a monthly fee, Goose is one of the best options available. It's not the only option. OpenCode is the other one worth knowing about. But Goose has the better desktop app and the more active maintenance.
If you're a student, a hobbyist, or someone who codes on the side, Goose is the answer. It's free, it's open source, and it will not send you a bill.
One more thing worth noting: the governance. Goose started as a Block project and was transferred to the Linux Foundation's Agentic AI Foundation. That matters because it means the project has institutional backing beyond a single company's roadmap. If Block had kept it, there would always be the risk of it being deprioritized or monetized. Under the Linux Foundation, that risk is lower. It's not zero, but it's lower. For a tool you're going to depend on, governance matters more than features.
The honest verdict
Goose is the best free AI agent I've tried in 2026. That's a high bar, because most free agents are either abandoned, half-baked, or secretly monetized. Goose clears it by being actively maintained, genuinely free, and flexible enough to use with any model you choose.
It's not as polished as Claude Code. It's not as fast as Copilot. It will not hold your hand. But it will not charge you, it will not lock you in, and it will not send your code to a server you do not control. For a lot of developers, that's the deal they've been waiting for.
Would you trade polish for control, or is the subscription worth it to you?
Top comments (0)