We like Goose

We spend a lot of time thinking about what to feed a coding agent. That's the whole point of GraphSlice. But the thing on the other end of the pipe matters too: the harness that holds the model, runs the tools, and decides what to do with the context it gets handed. Lately the one we keep reaching for is Goose.

One agent, two front doors

Goose ships in two forms, and the relationship between them is the part worth understanding.

There's a CLI, a proper terminal agent that runs shell commands, edits files, and drives multi-step work from where you already live. And there's a desktop app, which the marketing quite reasonably presents as a separate "distro." Install one or the other, pick your interface, off you go.

Here's the bit that made us trust it: the desktop app isn't a fork, it's a face. Both front doors read the same config.yaml. Your provider, your model, your enabled extensions, your keys. Configure them once and both the terminal and the GUI pick them up. The desktop app is a graphical skin over the exact same engine and the exact same configuration. It's not a second product that happens to share a name. It's not a something that's super clear at first glance and it's not a bug. Definitly a feature.

It's a small architectural decision with a big trust and ux payoff. You never have to wonder which Goose you're talking to. There's one agent. You just choose whether to look at it through a prompt or a window.

Batteries included, and the batteries are MCP

Most agents make you go shopping before they're useful. Goose ships with a set of built-in extensions that are really just MCP servers wearing a friendlier name, and the defaults are unusually good:

• developer does the core loop: run shell commands, write and edit files, walk the directory tree. This is the one that makes Goose an agent and not a chat window. (docs)
• computercontroller gives you platform-aware control of the machine itself, with its instructions adapting to the host OS.
• memory keeps durable preferences and facts across sessions, split between a project-local .goose/memory and a global store.
• tutorial and autovisualiser round out the defaults.

Because these are MCP servers, adding your own is the same motion as everyone else's. Goose exposes official servers for GitHub, Postgres, Slack and Jira, and the community has built a hundred-plus more. The out-of-the-box catalog is wider than most competitors expose on day one, so "install and it does something real" is true before you've configured anything.

This is also where Goose and GraphSlice speak the same language. GraphSlice serves code-graph slices over MCP, and Goose consumes MCP. Point it at the slice server and the agent stops guessing about your architecture and starts asking structural questions like who calls this and what breaks if I change that. That's exactly the kind of context a developer extension can't grep its way to.

Why people actually love it

Read around and the enthusiasm keeps landing on a few themes, and they're not the usual hype:

• It runs on your machine. Goose executes locally and is LLM-agnostic across 15+ providers: Anthropic, OpenAI, Google, Ollama, Bedrock, and more. Pair it with a local model and your code never leaves the building, which for regulated work is one of the few viable ways to have an AI coding agent at all.
• It goes beyond suggestions. The pitch on the tin is "install, execute, edit, and test." It does the work, not just the autocomplete.
• It's extensible by design. Being MCP-native from the ground up means you're never fighting the tool to make it talk to your stack.

And then there's the provenance. Goose comes out of Block, Jack Dorsey's company (the one behind Square and Cash App) and it's open source under Apache 2.0. But the part that actually sold us is why it exists. As Wired reported, Block didn't build Goose to ship a product. They built it to make themselves faster, and ran it internally for something like a year and a half before opening it up. By the company's own numbers, roughly three-quarters of its engineers say it saves them eight to ten hours a week, and a majority of the whole company reaches for it weekly. That's the opposite of a launch-day demo. It's a tool that had to earn its keep in-house first, which is a much better reason to trust it than any pitch deck.

The newer development is the interesting one. Block has handed Goose to the Linux Foundation's Agentic AI Foundation, putting it under neutral, community-driven governance with backing from AWS, Anthropic, Google, Microsoft and OpenAI. So it's not just open source in the license sense any more. It's fully open, out from under any single vendor's roadmap. A tool you're going to wire into your daily work is a tool whose governance you should care about, and Goose just moved in the right direction on exactly that axis.

The short version

Goose is a well-built open-source agent with one brain and two faces, a genuinely useful default toolkit, local-first execution, provider freedom, and governance that's heading somewhere durable. It also speaks the same MCP dialect GraphSlice serves, which makes it a natural harness for putting the right context in front of a model.

We like Goose. If you haven't given it a real afternoon, give it one.