Goose in NeuroSquadGoose,with a canvas around it
Run Goose in as many cards as you like, each a real `goose session` in its own terminal. Its status hook tells NeuroSquad when a turn starts and ends, its own approval prompt says what it asks, arrows give it browsers, terminals and notes, and every card resumes its session after a restart.
Official sitegoose-docs.ai- The real
gooseCLI, your own providers - Your Goose config is never written
- Free, for Windows 10 and 11
It knows when Goose is done — and when it’s asking
Goose runs a command of your choosing with `thinking` when a message goes to the model and `waiting` when its prompt is back. Every card gets its own. A question has no hook, so the card reads Goose’s own prompt for it.
GOOSE_STATUS_HOOK thinkingsignalGoose runs the card’s status hook with thinking. The card’s icon spins and the Squad card counts it as working. Subagents run inside the same turn and don’t move it.
◆ Tool approval requestsignalIn Goose’s approve modes a tool call waits on its ◆ prompt. The card reads it and the toast says Goose needs your permission: shell — rm -rf dist. In auto, Goose’s default, nothing asks.
GOOSE_STATUS_HOOK waitingsignalwaiting after a thinking: the prompt is back. The next queued prompt goes out, the journal gets the answer from Goose’s sessions.db, and a toast says it’s done.
Cancelled counts as finished
Ctrl+C mid-turn returns Goose to its prompt, and waiting ends the turn like any other — the card never hangs on “working”.
Questions, too
When a tool asks you something through Goose, the card shows Goose is asking: … with the question, and goes back to working once you answer.
Read from fixed words
The session id, the approval, the context bar and errors are Goose’s own printed words. If a future Goose rewords them, the card falls back to working/finished only.
Three things Goose does in NeuroSquad
Replicas of the app, played step by step. When Goose asks, the answer is yours.
In approve mode, Goose fixes a failing test, stops on its approval prompt before deleting a folder, and finishes — the journal writes itself.
Everything Goose can do in NeuroSquad
Goose gets nearly everything Claude Code does. Here is all of it — including where Goose works differently, and the two things that can’t be done.
- 01
Knows its state
Goose’s status hook and its own printed words report every turn.
Finished and waiting are different
The card sets
Docs: Finished and waiting are differentGOOSE_STATUS_HOOK: Goose calls it withthinkingwhen a message goes to the model andwaitingwhen its prompt is back — the exact start and end of every turn.A notification that says what it needs
No hook fires for a confirmation, so the card reads Goose’s own prompt:
Docs: A notification that says what it needsGoose needs your permission: shell — rm -rf dist, orGoose is asking: …for a question. A waiting toast stays until you answer.Cancelled turns end cleanly
Ctrl+C mid-turn cancels it — “Interrupted, what should goose work on instead?” — and the card marks it finished. At an idle prompt one Ctrl+C never quits Goose.
Docs: Cancelled turns end cleanlyPicks up where it left off
Goose picks its own session ids, so a card can’t choose one. The card reads the id from Goose’s banner (and after
Docs: Picks up where it left off/new) and resumes withgoose session --resume --session-id <id>.The Squad status card
Every AI agent of the workspace on one card, with its model from Goose’s own ledger — or
Docs: The Squad status cardGOOSE_MODELfrom your config before the first turn.
- 02
Works through the canvas
An arrow from the card is a set of tools, reached as a Goose extension.
Arrows are tools
An arrow to a browser, terminal, note or another agent gives Goose
Docs: Arrows are toolsbrowser_*,terminal_*,note_*oragent_*— in the very next request, because Goose drops its tool cache when the list changes.Canvas mode
Goose’s
Docs: Canvas modedeveloperextension is limited towrite,edit,treeandread_image— noshell— andcode_executionandcomputercontrollerto nothing. A tool that isn’t offered can’t be approved back, not even inauto.MCP servers from the registry
Installed servers arrive as a second extension. Goose asks before each call in its approve modes; in
Docs: MCP servers from the registryautoit wouldn’t, so NeuroSquad asks itself — once, for the session, or deny.Can’t pre-approve per card
Goose keeps per-tool permissions only in your own
Docs: Can’t pre-approve per cardpermission.yaml. So inapprovemode NeuroSquad’s own tools are confirmed like any other — “Always Allow” stays your choice. Inautonothing asks.Skills from skills.sh
An arrow to a skill card gives Goose
Docs: Skills from skills.shskill_loadwith each skill and when to use it — live, like every other arrow.
- 03
Built for long runs
Context, Compact, rate limits and a running journal — handled on the card.
Context meter
The latest request’s prompt from Goose’s ledger, the window from Goose’s own context bar (
Docs: Context meter15k/128k). The ring turns amber from 80%.Compact that doesn’t stop to ask
Compact sends “Please compact this conversation” — a phrase Goose compacts on at once.
Docs: Compact that doesn’t stop to ask/compactwould stop on an “Are you sure?”.Continues after a rate limit
Goose retries 429s itself, then prints
Docs: Continues after a rate limitRan into this error: …. The card shows the limit, and when the provider names a reset (“resets in 2h 15m”) it counts down and sends “continue”.Prompt queue
Line up the next messages: each goes out when
Docs: Prompt queuewaitingsays the turn is over.agent_sendfrom a lead Goose reaches a helper Goose the same way.Journal and hand-off
Goose’s last reply is read from its
Docs: Journal and hand-offsessions.db: the journal note, a hand-off to a fresh agent,agent_wait, custom cards and Telegram all get Goose’s real answer.
- 04
Works in a team
Your Goose config stays yours; each card gets a layer under it.
A config layer, not your config
Each card adds its own config.yaml through
Docs: A config layer, not your configGOOSE_ADDITIONAL_CONFIG_FILES, merged under your values key by key. Your Goose folder stays the only one Goose writes.Isolated worktrees
Give an agent its own git worktree, so parallel agents never edit the same files. A resumed session stays in the card’s folder.
Docs: Isolated worktreesAdd a reviewer
One click starts an agent on a different CLI in the same worktree, with a prompt to review without editing. Goose can be that reviewer too.
Docs: Add a reviewerDangerous mode, per card
Goose has no flag for it, so a card in dangerous mode runs with
Docs: Dangerous mode, per cardGOOSE_MODE=autoover your config: tool calls run without asking. Off by default.Instructions
Goose reads
Docs: InstructionsAGENTS.mdand.goosehintsfrom the project itself, and puts NeuroSquad’s session instructions into its system prompt from the extension.
- 05
Cost, control and access
What it spends, what it may spend, which model it runs on, and how you reach it.
Exact usage and cost
Goose logs one row per request in its
Docs: Exact usage and costusage_ledger: model, tokens and Goose’s own cost. Cached tokens are counted once, and subagent sessions fold into the card that started them.Budget brake
A limit per workspace. Past it, each Goose gets Ctrl+C — the turn is cancelled, Goose keeps running — and automatic prompts stop. Raise the limit and it’s lifted.
Docs: Budget brakeOpenRouter models
Goose’s built-in
Docs: OpenRouter modelsopenrouterprovider, set per card by environment. Goose hard-codes its own attribution headers, so OpenRouter traffic goes through a local relay that sends NeuroSquad’s instead.From your phone
Scan a QR code and the whole canvas opens in the phone’s browser: read Goose’s terminal, answer its question, send the next prompt.
Docs: From your phoneInstall it yourself
Goose ships as a native binary with no npm or winget package, so the setup wizard doesn’t install it. NeuroSquad finds
Docs: Install it yourselfgoose.exe— and skips the unrelated database tool that is also called goose.
Who’s waiting, and what it cost
Two cards that answer the questions you ask most when several Goose agents run at once.
The Squad status card
Every agent of the workspace with its status, model and turn time. The one waiting on you comes first, with what Goose asks.
- coupon-fixGoosegpt-5Goose needs your permission: shell — rm -rf distNeeds you3:51
- api-migrationGoosegpt-5Move routes to the new clientWorking12:24
- db-indexesGoosegpt-5-miniAdd the missing indexesWorking4:08
- docs-passGoosegpt-5-miniUpdate the READMEFinished6 min. ago
Usage & cost
Read from Goose’s own ledger on your disk and matched to the card by the sessions its banner named. The rows always add up to the total.
| Agent | Tokens | Cost | ||
|---|---|---|---|---|
| coupon-fix | 968,402 | $1.76 | ||
| api-migration | 604,117 | $1.09 | ||
| docs-pass | 201,936 | $0.09 | ||
| Total | 99 | 1,774,455 | $2.94 |
The real Goose, plus a config layer
NeuroSquad starts the same `goose` you run yourself, in a real terminal in the card. Goose has no settings flag, so most of this travels through a config file and the environment:
Survives new ports
A resumed Goose session reconnects the extensions saved with it, so their address is an environment reference — the card still reaches NeuroSquad after a restart.
Your login, your provider
Goose runs with the provider and key it already uses. Your NeuroSquad account is separate and never sees it.
A clean exit
Closing the window lets Goose close its session (“session closed · id”), leaving no stray process.
Goose in NeuroSquad, answered
Give Goose a canvas
Free for Windows 10 and 11. Your code, your providers and your costs stay on your machine.