Spiral x Goose: The Best is Yet to Honk
There comes a time in every brand’s life when they must update their shit. Sometimes this is motivated by royally messing up, while at other times it’s driven by concerns that people don’t know the brand is still breathing. This rebrand is neither. It was motivated by something far more necessary: the need for Spiral to expand its mission when getting bigger became more important, so we evolved to reflect that. How did we get bigger? By scooping up goose’s core developers from our parent company, Block. So while the cosmetic side of this rebrand speaks for itself (self-deprecation, black cats, the usual Spiral stuff), some explaining is in order about why the non-profit, open-source, R&D bitcoin initiative of Block needs an AI team. Quite simply, it doesn’t. But the agentic, open-source economy might.
Over the last seven years, we’ve gotten pretty good at building, funding, and promoting public goods, specifically those that have made money more open, secure, and accessible. Doing the same for AI makes sense in a world that, like money, is increasingly controlled by the very few. By joining Spiral, project goose is evolving from a single application into a development platform for the next generation of user-owned, user-controlled agentic software because the fight we’ve always picked (open over closed, yours over theirs) is now happening in AI too.
We do not believe that any one client, interface, or product can satisfy the full range of needs people will have for agentic AI. Individual builders, open-source projects, startups, enterprises, and specialized vertical applications will all need different capabilities, interaction models, security assumptions, deployment environments, and user experiences. Is Big AI going to give it to them? We doubt it.
Rather than trying to make one goose application serve every possible audience, our focus is on enabling many applications to be built on a shared foundation.
That foundation is the goose Development Kit, or GDK.
With the why out of the way, here’s the how. GDK will provide the core components developers need to build agentic applications using goose: agent orchestration, model access, context management, tools, memory, remote execution, automations, routing, and more. The goal is to make it possible for builders to create differentiated agentic products without having to recreate the hardest underlying infrastructure themselves.
Success for goose will not be measured solely by the adoption of one application. Success will be the sum of the clients, products, workflows, services, and experiments built on top of GDK.
We expect that to mean hundreds, and eventually thousands, of applications addressing every imaginable agentic use case—from individual local-first tools to sophisticated enterprise systems.
Into the GDK weeds
There are two ways developers can integrate goose into an application with GDK, either through ACP or the fully featured Rust API.
ACP for daemon-based integrations
ACP is an open protocol standard that gives clients and agents a shared interface. It allows applications to interface with goose as a separate process or daemon. This enables a client application to communicate with the goose agent while keeping the agent runtime independent from the application itself. ACP is used by many client applications already including Buzz, Codex, and Claude Code.
That model is useful for desktop applications, developer tools, integrations, and products that benefit from a durable local agent process with a clear boundary between the interface and the agent runtime.
A Rust API for embedded and fine-grained control
We are also developing a Rust API that will allow applications to embed the goose agent directly within the application itself.
This API is expected to be lower-level and more fine-grained than ACP. It will provide applications with deeper control over the agent loop, model behavior, context management, tools, memory, execution, and other aspects of the agentic runtime.
Applications written in Rust will be able to use the API directly. We also plan to provide language bindings for other popular languages, including Kotlin, Swift, Python, and others.
Over time, we expect ACP itself to be built on top of the Rust API. This will create a coherent core architecture while supporting multiple integration patterns for different kinds of applications.
GDK capabilities
GDK will build on goose’s existing capabilities while making them available as composable building blocks for other applications.
These include:
Resumable agent orchestration
Support for 50+ model providers through a unified interface
In-process local models
Context management
ACP server and client support
Remote access and execution
Pluggable slash-command infrastructure
Sub-agents
Skills
A pluggable memory system
Automations and scheduling
Router and dynamic model selection
A flexible agent loop
Code Mode
The objective is not simply to expose a collection of features. It is to provide dependable infrastructure that other developers can combine, extend, replace, and adapt to their own products—any products.
A builder may want to use the entire goose agent loop. Another may want only goose’s model-provider abstraction, context management, or tool system. An enterprise product may need specialized controls for storage, policy, security, permissions, or remote execution. A local-first client may want a deeply embedded agent runtime with direct access to local models.
GDK should make all of those paths possible.
The goose reference client
The existing goose application will continue to be maintained and will now be referred to as the goose reference client, or GRC.
GRC will remain an important application, but it will not attempt to become the universal interface for every agentic AI use case. Instead, it will be an opinionated power tool for users who want direct access to advanced agentic capabilities. GRC will also serve as a living reference implementation for GDK.
Every meaningful release of GDK should be reflected in the reference client. GRC will demonstrate best practices for using the platform and provide builders with a concrete example of how GDK capabilities can be combined in a real application.
This means that users and developers who want a different design, feature set, workflow, or business model do not need to wait for every idea to be added to GRC.
They can:
Fork GRC and add their own features
Build a new application from scratch using GDK
Work with community builders to create a purpose-built client
Adopt commercial products built on GDK for more sophisticated or specialized needs
Build a thin custom application that runs alongside GRC and works on the same session, focusing only on the specialized experience or functionality it adds rather than recreating the capabilities already available in GRC
The goal is not for goose to win by being the only client. The goal is for goose to succeed because it enables many excellent clients.
Why goose’s core team belongs within Spiral
Project goose has already been donated by Block to the Linux Foundation and the Agentic AI Foundation. The code is held by the Linux Foundation in service of the public good.
The full-time goose core developers are now part of Spiral. This reinforces the same principle: goose should be developed as broadly useful infrastructure, not as a project controlled by or optimized around the priorities of any one company.
Spiral’s role is to help advance goose as a credibly neutral platform for the entire ecosystem. That means prioritizing interoperability, broad adoption, public-good infrastructure, and the success of builders using goose across many different projects and organizations.
For the AI industry and for anyone evaluating agentic software, goose should be a platform they can adopt with confidence: one whose code is held by an independent foundation, whose development is oriented around ecosystem health, and whose purpose is to enable many applications rather than funnel users into a single company’s product.
Building the ecosystem around GDK
A development platform needs more than core code. It needs developers, applications, documentation, examples, integrations, design work, research, maintenance, education, and experimentation. Apologies for all the lists up until this point, we’re thinking big.
Spiral will support the goose ecosystem in several ways.
First, the core team will focus on making GDK a strong technical foundation for builders.
Second, Spiral will help advocate for goose and the applications built on top of it, complementing the work of AAIF, the Linux Foundation, and the wider community.
Third, the goose grant program will evolve as part of Spiral’s broader grant program. Spiral has operated a substantial grant program across bitcoin open-source projects, supporting more than 100 grants across more than a dozen projects. That experience will now expand to include goose and AI.
The purpose of grants is not only to fund core development. It is to support the broader set of people and projects that make a platform useful: developers, maintainers, researchers, designers, educators, application builders, integrations, and public-good infrastructure.
What comes next
The next chapter of goose is about enabling an ecosystem.
GDK will provide the foundation. The goose reference client will demonstrate what good use of that foundation looks like. And the broader community will create the specialized applications, workflows, and products that no single client could ever fully encompass.
We are stoked to share more in the coming weeks about the GDK roadmap, the Rust API, ACP, the goose reference client, grants, and opportunities for the community to contribute.
Goose should become infrastructure that anyone can build on — open, adaptable, credible, and useful across the full range of agentic AI.
Now go check out the rebrand.