goose Doubles Down on Open in Latest Two Releases

* Angie Jones VP of Developer Experience, Agentic AI Foundation ---------------------------------------- goose is an open source AI agent runtime hosted at the Agentic AI Foundation. Its last two releases, versions 1.36 and 1.37, dropped in quick succession and together push goose further open. Here’s what shipped. IMPROVED ACP SUPPORT If you haven’t been following ACP (Agent Client Protocol), it’s worth understanding what it’s trying to do. The basic idea is to separate the agent runtime from the agent interface so that goose (the thing that actually reasons and acts) doesn’t care whether it’s being talked to from a terminal, a Slack bot, an IDE plugin, or a custom web dashboard. These releases add a meaningful set of ACP capabilities: streamable HTTP compliance, slash commands over ACP, session pagination, image replay, context-window forwarding, and per-session system prompts. That last one is particularly useful because it means different clients can give goose different context and constraints without stepping on each other. This is great for openness because without a common protocol layer, every new interface means re-integrating the runtime from scratch. With ACP, the runtime is a stable foundation that any interface can build on. That’s the difference between a tool and a platform, and it’s the kind of thing that only works if the protocol is open and the runtime is portable. MORE PROVIDERS, LESS LOCK-IN These releases add 9 new model provider integrations: * Alibaba Qwen via DashScope * Perplexity * Databricks AI Gateway * Vercel AI Gateway * xAI SuperGrok subscription * Scaleway * NEAR AI Cloud * oMLX * GitHub Copilot /responses But the more interesting story is how they’re added. Many of these are now declarative providers configured entirely in YAML. That means you can manage your AI provider the same way you manage the rest of your infrastructure config, and swap it out in environments where the model choice isn’t yours to make. You shouldn’t be stuck with a provider just because switching is too painful. The more portable the runtime, the more genuinely open it is. RUN IT ANYWHERE: LOCAL INFERENCE GETS REAL Anyone paying attention to local AI knows two things: the models are getting genuinely good, and the cloud inference bills are getting genuinely painful. goose has always supported local inference, but these releases make it substantially better across more hardware such as Linux Vulkan acceleration, Alpine/musl builds for minimal environments, Windows CUDA artifacts, and native arm64 Linux runners. And there’s stricter GGUF model validation so you catch bad models before they cause weird behavior at runtime. An agent runtime that only works well if you’re piping everything through a cloud API isn’t really open in any meaningful sense. Running locally matters for cost, for privacy, for latency, and for the growing number of deployments where the data simply can’t leave the machine. These improvements make that a more realistic option for more people. HOOKS: GOVERNANCE BUILT ON AN OPEN SPEC One of the most practically important additions in these two releases is also one of the quietest. v1.36 introduced PreToolUse denial hooks as a way to intercept what goose is about to do and block it before it executes. v1.37 extended this with blocking Stop hooks. What this means in practice is that you can now define policy at the runtime level. Don’t want goose touching certain files? Block it. Running goose in a shared environment where certain API calls are off-limits? Block those too. Before this, you could watch what goose did after the fact. Now you can prevent it. Importantly, goose’s hook system is built on the Open Plugins hooks specification which means the same hook logic you write for goose is portable across any runtime that implements the spec. That’s not a small thing. It means governance tooling you build today isn’t goose-specific; it’s part of a broader open ecosystem. ORCHESTRATION: EARLY DAYS, REAL FOUNDATION These releases lay the groundwork for an orchestration system: subagent instructions, dynamic skill refresh, project-backed system prompts, and scheduled recipes. If you’ve been waiting for goose to support more complex, multi-step workflows that run without someone sitting at a keyboard, this is the beginning of that. It’s early. But it’s the right kind of early, where the primitives are solid and the direction is clear. THE QUIET STUFF THAT ACTUALLY DETERMINES ADOPTION The releases also add a /goal command that lets goose evaluate whether it actually completed what it set out to do (which sounds obvious but turns out to be surprisingly useful for longer-running tasks), along with improvements to prompt-injection handling and stricter local model validation. Other additions include * first-class TUI support * inline diff viewing * local code review * model switching mid-session * token visibility for skills * Nushell support * worktree awareness * better session handling Developer tools live or die on whether they fit into the way people actually work. The flashy stuff gets you the first try. The polish gets you the daily use.