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. 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 same engine and the same configuration. It's not a second product that happens to share a name. That isn't obvious at first glance, and it isn't a bug. It's a feature.

It's a small architectural decision with a big payoff in trust and UX. 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 Model Context Protocol (MCP) servers wearing a friendlier name. 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. Its instructions adapt 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. The community has built a hundred-plus more. The out-of-the-box catalog is wider than most competitors expose on day one. "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 context slices over MCP, and Goose consumes MCP. Point Goose at GraphSlice and the agent stops hallucinating answers about your architecture. It starts asking structural questions instead: 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. 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. For regulated work, that's 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. Goose is MCP-native from the ground up, so you never fight 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. They 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. A majority of the whole company reaches for it weekly. That's the opposite of a launch-day demo. The tool 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. That puts 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 build into your daily work deserves governance you can trust, 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. It has a genuinely useful default toolkit, local-first execution, provider freedom, and governance headed somewhere durable. It also speaks MCP, the same protocol GraphSlice serves context slices over. That 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.