
This is what productivity with a team of agents actually looks like.
One lead holds the moving parts. Specialists research, plan, implement, review, and ship in parallel. Every DM, tool call, diff, document, and background command stays visible in one native workspace.
goldengoose runs the real Codex, Claude, and OpenCode harnesses, so each model keeps the tools and subscriptions it already knows. A Rust runtime owns the state underneath. The frontend renders it; it does not invent a second version of the truth.
- 01
- One teamA persistent, flat roster with one lead.
- 06
- Six toolsThree for teams. Three for processes.
- 03
- Three providersCodex, Claude, and OpenCode per thread.
Bring your own tokens
Use the ChatGPT and Claude subscriptions you already pay for.
If Codex or Claude Code is already signed in on this Mac, goldengoose reuses those local credentials. No second login. No separate API setup. Why subscriptions are the default.


One lead, a visible roster
The lead stays available. Everyone else ships.
The lead is a judgment engine, not an implementer. Keep giving it work while researchers, planners, implementers, reviewers, and testers move in their own threads and managed Git worktrees.
Adding a teammate creates a member you can watch, address, and interrupt. Give it a role, a model preset, an assignment, and—when the work needs isolation—a named worktree.
Responsibility can be hierarchical. Access stays flat.
DMs, broadcasts, receipts
A group chat is the orchestration layer.
Any member can message any other member directly. Broadcasts reach the current roster. Images travel with the message, so a bug screenshot can move from you to the lead to the agent fixing it without being translated into somebody else's words.
This is coordination without hierarchy: delivery is not a hopeful append to a chat log. The Rust runtime tracks each recipient from queued through injected or failed, and Team Comms gives the whole team one canonical stream.
Context without scavenger hunts
The prompt knows the workspace.
Two small completions remove a surprising amount of friction: the playbook you meant and the exact file you meant, inserted before an agent gets a chance to guess.
Skills are part of the sentence.
Type $ to search installed skills by name and purpose, then hand the agent the versioned playbook the job actually needs.
Files arrive as exact paths.
Type @ and the native, gitignore-aware workspace index finds files and folders without making the UI scan the repository on every keystroke.
The reading desk
Reading is the bottleneck. The viewer is native.
Specs, research reports, implementation plans, and handoffs all become Markdown—and reading is the bottleneck once agents can generate them faster than a human can review them. File View renders them with Comrak and syntect in Rust and keeps them current while agents edit.
The tree is Markdown-only on purpose. Search paths, search the whole workspace, find text inside the open document, or jump through its table of contents without opening another IDE just to read.
Search the document. Search the tree.
A real file tree and in-document find turn a large spec into something you can navigate, not another wall of terminal prose.
Mermaid renders where the plan lives.
Architecture diagrams stay inside the document that explains them, rendered with the same live-update behavior as the rest of the page.
Review while it moves
See the work while it is still becoming work.
Changed files, per-file line counts, branch state, and a real diff stay scoped to the agent or worktree in focus. Review a full patch without leaving the conversation that produced it.
Recent commits
Commit history is a lookup surface.
Fuzzy-search hashes and messages, copy the exact commit, and point an agent at it without making either of you spend a turn rediscovering what already happened.
Background work with an owner
Long commands should wake the agent, not trap it.
An agent starts a build, test suite, or dev server and ends its turn. The Rust-native Process Manager owns the command, working directory, timeout, permissions, and bounded stdout and stderr logs.
When the process exits, the result is injected back into the thread that started it and that agent resumes. The deeper rule is that background processes belong to the runtime: no polling, no pasted logs, and no completion leaking into whichever conversation happens to be active.
Useful interruption
You should not have to watch the app watching your agents.
Native macOS notifications carry the agent, workspace, and completion that matters. Reply inline when a message deserves an answer; tune everything else until the team is quiet enough to trust.
Inline reply
The conversation can meet you outside the window.
Notification actions are wired through native macOS integration instead of imitating a system panel inside the webview.
Choose which completions deserve a notification.
Set the default lead model and select all, none, or leads-only completion notices.
Route context-loss signals to whoever can act.
Compaction notices can go to the lead or the teammate's creator—the member most likely to still hold the original assignment and recovery plan.
The boring answer is the reliable one
One source of truth, and a frontend that never guesses.
Session and turn lifecycle, event fanout, persistence, delivery, worktree ownership, and process control live in the Rust runtime. Generated TypeScript bindings turn a changed backend contract into a compile error instead of a production surprise.
Providers sit behind one lifecycle without pretending they are identical. Codex keeps the Codex app server, Claude keeps the Claude Agent SDK, and OpenCode keeps its own server; goldengoose absorbs the differences above them.
- desktop
- Tauri v2 · React 19 · native macOS integrations
- runtime
- Rust · SQLite · typed lifecycle and bounded streams
- providers
- Codex app server · Claude Agent SDK · OpenCode
- workspace
- Git worktrees · live diff · native file watchers and indexes
The entire coordination surface
Six tools. On purpose.
Small enough to stay in context. Sharp enough to run a real team and its long-lived work.
gg_messagesend a DM or broadcast, with real delivery trackinggg_team · statusread the roster, roles, activity, context, and worktreesgg_team · manageadd, remove, or assign a teammate to a worktree
gg_process · runstart owned background workgg_process · statusinspect the process and its bounded logsgg_process · cancelstop work that should not keep running
goldengoose is the app used to build goldengoose. Roughly 90% of it has been built inside its own agent teams.
Available for macOS
The agents can do the work. Keep the whole system in view.
Curious how it came together? Read the full project story.