Skip to content

Goose (aaif-goose/goose, formerly block/goose) ​

Produced by the ACP product case-study pass (2026-07-30), then adversarially verified; corrections below override the body where they conflict.

Goose: research case study for trogonai ACP integration ​

Goose (github.com/aaif-goose/goose, historically github.com/block/goose) is Block's open source, local-first coding agent, donated to the Linux Foundation's new Agentic AI Foundation (AAIF) in early 2026 alongside MCP and AGENTS.md (https://www.linuxfoundation.org/press/linux-foundation-announces-the-formation-of-the-agentic-ai-foundation, https://goose-docs.ai/blog/2026/04/07/goose-moves-to-aaif/). The GitHub org is now aaif-goose, not a fork of block/goose but the canonical repo under new governance (verified via gh api repos/aaif-goose/goose: fork: false). It is Apache-2.0 licensed, Rust-based, at v1.45.0 as of 2026-07-29 (https://github.com/aaif-goose/goose/releases).

ACP status: native, both agent and client ​

Goose implements ACP natively as an agent: the CLI subcommand goose acp runs a stdio JSON-RPC ACP server, listed directly on Zed's agent registry (https://zed.dev/acp/agent/goose) and documented at goose-docs.ai/docs/guides/acp-clients. Its Cargo.toml pins agent-client-protocol = "1.0", agent-client-protocol-schema = "1.1" (unstable features), and agent-client-protocol-http = "1.0" (server + unstable_cancel_request features) (verified from Cargo.toml source). Separately, Goose exposes ACP over Streamable HTTP with a WebSocket upgrade via a goose-acp crate, intended to become the primary transport for Goose's own first-party clients (desktop Electron app, a new TypeScript TUI), per an explicit 4-phase migration plan discussed by maintainers (https://github.com/aaif-goose/goose/discussions/7309). Auth for that HTTP path uses GOOSE_SERVER__SECRET_KEY, checked via X-Secret-Key header or ?token= (https://goose-docs.ai/docs/guides/acp-clients/).

Goose is simultaneously an ACP client: its "ACP Providers" feature lets Goose delegate a turn to another ACP agent (Claude Code, Codex CLI, Amp, Pi) via GOOSE_PROVIDER=claude-acp|codex-acp|amp-acp|pi-acp, passing Goose's own configured MCP extensions through to the delegate agent as MCP servers (https://goose-docs.ai/docs/guides/acp-providers/). Session resume/fork are explicitly not yet supported on that client path.

Integration wiring ​

Process model: stdio subprocess for editor integration (goose acp, spawned by the editor/client), or long-lived HTTP+WS server (goose serve) for first-party clients. Permission requests and fs/terminal RPCs are handled the standard ACP way: Goose's crates/goose/src/acp/fs.rs issues ReadTextFileRequest, WriteTextFileRequest, CreateTerminalRequest, KillTerminalRequest, WaitForTerminalExitRequest, TerminalOutputRequest, ReleaseTerminalRequest back to the ACP client via agent_client_protocol::Client / ConnectionTo<Client>::send_request (source verified). This means Goose does not do fs/terminal I/O locally when acting as an ACP agent; it always round-trips through the client, exactly matching the spec's intended client-role responsibilities. MCP server configs set under the client's context_servers are automatically surfaced to Goose without extra wiring (goose-docs.ai/docs/guides/acp-clients).

Channel mapping ​

Goose itself does not map Slack/Telegram/WhatsApp/voice into ACP sessions; that is Buzz's job. Buzz (Block's open-source human+agent workspace, https://engineering.block.xyz/blog/buzz) is model- and agent-agnostic and ships harnesses for Goose, Codex, and Claude Code, treating Goose as one interchangeable backend rather than privileging it (https://explainx.ai/blog/jack-dorsey-block-buzz-ai-agents-team-chat-git-2026). Inference: Buzz likely uses its own per-agent harness layer rather than raw ACP for chat-channel fan-out; this was not independently confirmed against Buzz's source.

Callability from trogonai today ​

trogonai's acp-nats-agent can plausibly spawn goose acp as a stdio child process the same way Zed does, bridging stdin/stdout JSON-RPC frames onto NATS subjects. Concretely: GOOSE_PROVIDER=<provider> GOOSE_MODEL=<model> ANTHROPIC_API_KEY=... goose acp, cwd set to the target workspace. Headless viability is good for the LLM-provider path (just an API key env var, no interactive login), but poor if using Goose's ACP-Providers-as-client mode with Claude Code/Codex, since those require their own OAuth device/login flows. The main unverified risk is ACP schema/version skew: Goose pins ACP SDK 1.0/1.1 while trogonai pins SDK 2.0.0 wire v1; the initialize/capabilities handshake needs to be checked for compatibility before treating this as a drop-in.

Design lessons ​

Copy: strict separation of agent-role and client-role responsibilities, Goose never touches the filesystem or terminal directly under ACP, it always calls back through the client's fs/terminal RPCs, which is the cleanest possible boundary discipline and worth mirroring in trogonai's own ACP agent implementations. Also worth copying: exposing both a lightweight stdio transport for editor-style clients and a separate HTTP/WS transport for first-party long-lived clients, rather than forcing one transport to serve both use cases.

Avoid: Goose's ACP-Providers client mode has no session resume/fork, a known gap; trogonai should not replicate that limitation if it builds an analogous "call out to another ACP agent" capability. Also avoid conflating governance-driven repo moves (block/goose to aaif-goose/goose) with a fork; trogonai's own docs referencing Goose should track the canonical org going forward.

Sources ​

Adversarial verification ​

  • confirmed: Claim 1: ACP status is native via goose acp CLI subcommand (stdio JSON-RPC, agent side) in goose-cli, backed by crates/goose/src/acp/*, using agent-client-protocol = "1.0" (Fetched crates/goose-cli/src/cli.rs directly: Command::Acp variant with doc comment 'Run goose as an ACP agent server on stdio', dispatches to goose::acp::server::run(); root Cargo.toml pins agent-client-protocol = "1.0" (default-features=false) exactly as claimed.)
  • confirmed: Claim 1: goose serve / the 'goose-acp crate' exposes ACP over HTTP+WebSocket for first-party clients (desktop/TUI) (cli.rs shows a Serve command starting an ACP server over HTTP/WebSocket/TLS using goose::acp::server_factory::AcpServer and goose::acp::transport; however there is no standalone 'goose-acp' crate in the repo (only goose-acp-macros exists) -- the HTTP+WS ACP server code lives in crates/goose/src/acp/*, a module inside the goose crate, so 'goose-acp crate' is a minor misnomer for what is actually a module; the underlying HTTP+WS-for-first-party-clients claim itself is confirmed by the 2026-04-08 official blog post describing goose serve/ACP unifying TUI and Tauri desktop clients.)
  • confirmed: Claim 1: Goose is also an ACP client via 'ACP Providers' (GOOSE_PROVIDER=claude-acp|codex-acp|amp-acp|pi-acp) to drive Claude Code, Codex, Amp, or Pi as sub-agents (Fetched documentation/docs/guides/acp-providers.md directly from the repo: it lists exactly Amp ACP (amp-acp npm package), Claude ACP (GOOSE_PROVIDER=claude-acp), Codex ACP (GOOSE_PROVIDER=codex-acp), and Pi ACP (pi-acp binary), matching the claim verbatim.)
  • confirmed: Claim 2: Callability verdict 'yes' -- a Rust ACP client host (trogonai's acp-nats-agent/bridge) can spawn goose acp as a stdio subprocess like Zed/JetBrains, per the same agent-client-protocol Rust SDK family, noting goose pins =1.0 vs trogonai's 2.0.0 and flagging this as a compatibility risk to verify (Confirmed goose Cargo.lock resolves agent-client-protocol to exactly 1.0.1; confirmed via crates.io API that agent-client-protocol 2.0.0 is a real, stable, published release (2026-07-23, not alpha); confirmed trogonai's workspace Cargo.toml pins agent-client-protocol = "=2.0.0" and that acp-nats-agent/acp-nats-stdio crates exist in the repo. The claim's own hedge (verify compatibility at integration time) is corroborated as a genuine, non-trivial major-version gap rather than refuted -- claim 2 does not overclaim compatibility, it flags the risk accurately.)
  • confirmed: Claim 2: Permission requests (session/request_permission) and fs/terminal RPCs (fs/read_text_file, fs/write_text_file, terminal/create, etc.) are standard ACP client-role callbacks goose already relies on, requiring no goose-specific handler (crates/goose/src/acp/fs.rs, fetched directly, shows goose calling ReadTextFileRequest, WriteTextFileRequest, CreateTerminalRequest, ReleaseTerminalRequest, WaitForTerminalExitRequest, KillTerminalRequest, TerminalOutputRequest via agent_client_protocol::{Client, ConnectionTo}.send_request -- i.e. goose delegates these to whatever ACP client is driving it, confirming no goose-specific handler is needed on the client side.)
  • confirmed: Claim 2: MCP passthrough -- goose auto-exposes context_servers configured on the ACP client side to the agent (not independently verified beyond docs) (documentation/docs/guides/acp-clients.md, fetched directly, has a section 'Using MCP Servers from ACP Clients' stating context_servers configured in the ACP client are automatically available to goose (stdio/HTTP transports only, not SSE); this matches the claim, which itself correctly flagged this as doc-sourced rather than code-traced.)
  • confirmed: Claim 3: Goose ships a native ACP agent invoked as goose acp; Zed and JetBrains configure it under agent_servers with command 'goose', args ['acp'] (documentation/docs/guides/acp-clients.md (the actual doc path, not 'acp-clients' guide as separately named in the citation which was slightly imprecise on filename but correct on content) shows the exact JSON: agent_servers.goose = { type: 'custom', command: 'goose', args: ['acp'] }, matching the claim; zed.dev/acp/agent/goose page itself was thin on detail but the primary repo doc confirms it.)
  • confirmed: Claim 3: Cargo.toml pins agent-client-protocol = "1.0" (default-features=false), agent-client-protocol-schema = "1.1" (features=["unstable"]), agent-client-protocol-http = "1.0" (features=["server","unstable_cancel_request"]) (Fetched root Cargo.toml via gh api directly: lines match verbatim -- agent-client-protocol-schema = { version = "1.1", default-features = false, features = ["unstable"] }, agent-client-protocol = { version = "1.0", default-features = false }, agent-client-protocol-http = { version = "1.0", default-features = false, features = ["server", "unstable_cancel_request"] }.)
  • confirmed: Claim 3: block/goose is now aaif-goose/goose (canonical, not a fork) after Block donated Goose to the Agentic AI Foundation (AAIF) under the Linux Foundation in early 2026 (curl -I on github.com/block/goose returns HTTP 301 redirecting to github.com/aaif-goose/goose (GitHub's canonical-rename redirect, not a fork relationship); gh api repos/block/goose itself resolves to aaif-goose/goose; goose-docs.ai blog post dated 2026-04-07 explicitly states the repo moved from block/goose to the new aaif-goose org; Linux Foundation press release confirms AAIF formation with goose as a founding contribution.)
  • confirmed: Claim 3: Repo license is Apache-2.0; latest tagged release as of research date is v1.45.0 (2026-07-29) (gh api repos/aaif-goose/goose confirms license 'Apache License 2.0'; gh api repos/aaif-goose/goose/releases confirms tag_name v1.45.0 published_at 2026-07-29T20:11:39Z as the most recent non-prerelease release, and Cargo.toml workspace.package.version = 1.45.0 matches.)
  • confirmed: Claim 3: ACP fs/terminal handling lives in crates/goose/src/acp/fs.rs and calls standard ACP Client capability requests via agent_client_protocol::Client/ConnectionTo<Client>.send_request, delegating fs/terminal ops back to the ACP client (Directly fetched and grepped crates/goose/src/acp/fs.rs: imports agent_client_protocol::{Client, ConnectionTo}, defines functions using ReadTextFileRequest, WriteTextFileRequest, CreateTerminalRequest, ReleaseTerminalRequest, WaitForTerminalExitRequest, KillTerminalRequest, TerminalOutputRequest, all invoked via cx.send_request(...) where cx: &ConnectionTo<Client> -- matches the claim exactly, including the specific request type names.)

Corrections (authoritative where they conflict with the body) ​

No corrections were required for this dossier; all claims and sub-claims were confirmed against primary sources (goose-docs.ai guides, the aaif-goose/goose repository's Cargo.toml and source, the Linux Foundation press release, and trogonai's own Cargo.toml and acp crates), with only minor naming imprecision noted (the "goose-acp crate" is actually a module inside the goose crate, not a standalone crate).

Released under the Apache License 2.0.