Local agents, MLX models and your own machines, connected in one desktop app.
Apple Silicon macOS. Goose Swarm 3.0.110 is Developer ID signed and notarized.
Installation & user manual
Keep working on your laptop while a linked machine handles an agent task. Sign in on your devices, bring them onto your private mesh, and choose where the work runs.
Link brings device discovery, availability and remote prompt execution into Goose Swarm. The destination keeps its own workspace and compute. Your laptop does not need to hold every model.
LeanZero Link ships inside Goose Swarm and, for now, works only there. How sign-in works, why it needs your email, and how to allow remote runs.
Choose the task and target
Run the agent in its workspace
If you know LM Studio’s LM Link, the goal will feel familiar: use compute on another machine from the device in front of you. LM Link exposes remote models inside LM Studio. LeanZero Link connects Goose devices and lets you dispatch agent work to them.
They are separate products and separate networks. LeanZero Link is not an LM Studio integration or affiliation.
Goose runs its own userspace Tailscale mesh, isolated from your existing Tailscale installation. Email-code sign-in associates your devices; authenticated device traffic uses the mesh. Only link machines you trust.
The target must be awake, and it only accepts remote runs after its owner switches them on. Link does not synchronize your project files automatically, and choosing a cloud provider still sends inference requests to that provider.
Goose Swarm 3.0.110 runs two independent Forge benchmark builds from one desktop action, using the same selected provider configuration. Each build keeps its result and evidence. When both completed results are comparable, the app reports their median and range.
Cancellation covers the gap between builds. Reopening the app preserves the saved outcome without automatically replaying paid work. The release keeps the frozen Forge 2.0 task and scorer unchanged. Read the 3.0.110 release notes.
Goose 3.0.4 improved benchmark failure explanations and preserved complete browser recordings. The SB7.1 task and numeric scoring rules were unchanged.
New grading evidence retains the complete browser recording in original order and at original speed. The website player shows duration and position, supports seeking and makes the ending and replay explicit. Older excerpts remain identified as clips.
Initial synchronization and later recovery are reported separately. The published Gemini explanation is corrected without changing its score, original scorer provenance or Goose 3.0.2 build attribution.
Run the latest stable benchmark published in the catalog. Legacy, beta and alpha benchmarks cannot be launched from the app.
The app fetches the current catalog before starting a model build or retrying scoring. If it cannot verify the current release, the action stops with an explanation.
If the bundled benchmark is older than the current published version, update Goose before running it. An older saved build cannot be retried against a different benchmark.
Earlier results, checks and recorded media remain readable. Launch restrictions do not rewrite historical scores or make different task versions comparable.
This maintenance release improves reporting and recording. The SB7.1 task, numeric scoring rules and published 49.92% score are unchanged; that model build was completed with Goose 3.0.2.
Read the 3.0.4 release notes. The 3.0.2 release introduced SB7.1, benchmark tools, activity and scoring retry. Earlier releases introduced Agent Work, memory and skills, LeanZero MLX, and agent-creation and MCP-setup refinements. Read the 3.0.0 release notes or the 3.0.1 maintenance notes.
Actual captures from the 3.0.1-based review installation. Agent creation includes the maintenance release’s layout refinements. Screenshots are expandable, with no fabricated activity or connected devices.
Forge 2.0 asks one model to ship v2 of an installed Jira app in an offline harness. Goose runs two independent builds and retains each result so you can inspect what the model delivered.
The payments result below is historical SB7.1 evidence. That task asked an agent to build the Meridian Payments Console from an editable starter, combining backend consistency and recovery with a live 3D payment field, a detailed inspector and animation driven by committed updates.
For that historical task, the app recorded model activity, individual checks, screenshots and a clip from the graded browser. Swarm nodes could mix local and cloud providers; Single model used one configured provider.
The app built real payment geometry and committed-update animation, but failed important money, recovery and presentation checks. Initial synchronization completed with only 8,388 payments; daily bucket counts did not match the full fixture, applying a ×0.6 critical multiplier. Later recovery was measured separately. The 69.9% admission ceiling did not reduce the score further because earned credit was already lower.
Model build: 10m16s. Final scoring retry: 14m14s. Earlier interrupted and failed grading attempts are additional. The retry used the saved completed build without another model call. This one result does not establish subjective artistic excellence or how every leading model will perform.
Inspect the published run and videoEarlier evidence remains separate: the preserved development candidate scored 79.9% with 96.83% earned before its ceiling. The historical 69.9% Gauntlet 7.1 pilot retains its original sb-7.1-rc task and evidence.
We will keep shipping maintenance and feature releases. Compatible stable updates will be available through the app’s automatic updater and the official GitHub release page.
Use Settings → App → Updates to check now. Automatic downloads are optional; the screenshot shows them disabled. Save your work before a restart, or replace the app manually with the latest DMG.
From your first installation to a linked agent workspace. Open a chapter for the actual controls, prerequisites and recovery steps.
Choose Download for Mac to download the DMG directly. See release opens the GitHub release notes and other assets. The published macOS package is for Apple Silicon (arm64); do not use it as an Intel Mac installer.
Open the disk image, drag Goose.app into Applications, then eject the disk image. Launch Goose from Applications. A normal first-open confirmation for an internet download can still appear on a notarized app.
The 3.0.110 macOS arm64 release is Developer ID signed and notarized. Notarization checks the distributed software; it is not a guarantee about generated code or third-party models.
If macOS reports that an app is damaged or its signature is invalid, stop and download a fresh copy from the official release. Do not disable Gatekeeper or remove quarantine attributes as a routine installation step. Report the exact version and message if it persists.
Goose local edition is LeanZero’s open-source fork of Goose. Source code, release assets and development history are available on GitHub.
Building a local-model coding agent and a benchmark honest enough to fail its own authors.
Our port reclaim logged a warning every single time it ran in the shipped app, and nobody noticed for weeks — because the warning branch was the only branch that could execute there. macOS keeps lsof in /usr/sbin, and a packaged app's PATH does not have it.
The model was fine. GPT-5.6 Sol driven from goose's own engine did good work. Driven from Codex it gold-plated the quality gates until a ten-minute rebuild took over an hour, and it never once got to the end. Six days, zero completed runs, and a bill I cannot justify to anyone.
Every number this benchmark ever published was wrong at least once. The transferable part is not the scorer, it is the six disciplines that caught each lie: prove the lever moves before you A/B it, prove the grader in both directions, pre-register the falsifier, positive-control every zero, spell absence and failure differently, and fix the report when the score is right but unreadable.
goose Local Edition is our fork of goose with a swarm engine and an execution-based scorer. The scorer boots the built application, drives it over HTTP and in a browser, and prices what a user would actually experience. On the current board our own fleet is last of seventeen at 0.0172 — here is why that number is the point.
A worker in my local-model swarm ran pytest against a file that did not exist, twice, and finished the task green. The pipe had eaten the exit code. Measured on bash and zsh, on pytest and cargo — including why turning pipefail on just moves the lie to the other side.
Our swarm workers kept re-reading files they had already read. Context compaction was summarising the tool output that held the file. Pasting the file into the summary does not fix it; returning the last turns verbatim does. Measured three ways on the same 27B.
Three weeks after the swarm shipped its first honest builds, the work stopped being about making small local models smarter and became about making them stop lying to me. Here is what 602 commits bought, what the desktop looks like now, and the three defects I found in my own honesty machinery while writing this post.
A hands-on walkthrough of swarm-gym — the harness that drives goose local-edition's swarm through real coding tasks and grades the result by running it. Set it up, run both modes, read every output, and tune the swarm from what you find.
We built a harness that makes local coding agents produce real software, grades it by running it, and ran the same model as GGUF and MLX. Here's the harness, its modes and archetypes — and which build to run.
The engineering teardown of goose local-edition: how the scheduler, the parallel planner, the CONTRACTS discipline, the model-free judge, and the post-run smoke/AST gates are actually implemented, why each exists — and the self-driving test harness that found the failure behind every one of them.
We forked Block's goose into a multi-agent swarm that decomposes a hard app spec into a task DAG, runs it across three small local models on LM Studio, and makes them verify their own work by actually running it. Over six days and 300-plus commits, the last real limit stopped being the swarm's coordination and became the small model's raw coding ability — and even that ceiling moved.