Squad 0.11.0 is out: Squad 0.11.0 — portable teams, sharper Copilot App execution, and a harder release train. The release includes 104 merged PRs from 8 PR authors, plus the usual patient work from automation. It is a practical release: teams are easier to share, easier to run inside Copilot, and a lot less fragile for people who are not me.
Squad started as a local workflow. It was my repo, my agents, my odd little habits, and a lot of hand-tuned context. That was useful. It was also too personal to be the whole idea. I want Squad teams to live with the work. It should be repo-native. It should carry decisions, roles, skills, and memory near the code. In 0.11.0, a lot of the work is about making that idea portable without asking you to inherit somebody else’s whole setup.
A contributor note up front. Tamir Dresher, Squad’s co-creator, did a lot of the work that gives this release its shape. The contributor list in the release includes @bradygaster, @tamirdresher, @Meir017, @primetimetank21, @IEvangelist, @ahhlun, @duongau, and @obit91. That work made this release sturdier.
portable teams, not portable personal baggage
The feature I would point most people at first is squad preset install, which closes #1224. It installs one Squad preset from a GitHub URL or a local path into your normal $SQUAD_HOME/presets/<name>/ folder. That sounds like a small command, and in the best way, it is. The useful part is what it does not ask you to do.
Before this release, squad preset init --remote worked if you wanted to clone an entire SQUAD_HOME repository. That was fine for syncing one person’s machines. It was too blunt for sharing one team. If I wanted to hand you a release squad or a research squad, the path was too manual: clone a repo, find the right preset directory, copy it into your own home, then apply it. Or worse, temporarily point SQUAD_HOME somewhere else and hope you did not stomp on your own state.
Now the shape is cleaner:
squad preset install https://github.com/org/squad-presets#release-team --name release-team
squad init --preset release-teamor, if the repo already has Squad initialized:
squad preset apply release-teamThat means a team can become an artifact. A consultant can share a review squad. A maintainer can publish a release squad. A workshop can hand attendees a known-good set of agents without asking them to clone the presenter’s entire personal environment. This is not a marketplace, an update system, or a lifecycle manager. preset uninstall, preset update, and a public catalog are still separate work. For 0.11.0, the goal is simple: one useful team can travel by URL and become a normal local preset.
we are casting agents now
The command vocabulary changed too. In #1394, squad hire became squad cast. The old command still works as a quiet compatibility alias, including help resolution, so existing muscle memory does not break. But the new word fits the model better.
This is not a technical execution change, and I do not want to dress it up as one. It is a meaning change. We are casting agents, not hiring humans. Squad uses a production metaphor because the work feels closer to assembling a cast than pretending a company is adding employees. You cast a researcher, a reviewer, a release manager, a diagrammer, or an editor for the work in front of you. The role matters. The context matters. The repo is the set.
So the old version looked like this:
squad hire --name DeepBackground --role ResearchManagerThe new version is this:
squad cast --name DeepBackground --role ResearchManagerThat may look like polish, and it is. But language sets expectations. Squad should not sound like it is replacing a team or pretending agents are people. The command should describe composing a group of Copilot-driven specialists around a repo, with names, roles, boundaries, and receipts.
better Copilot App execution
One of the larger internal changes is #1385, which adds a SpawnBackend abstraction. In plain terms, Squad can now choose how to dispatch cast members based on the Copilot surface it is running in. In the Copilot App / Tauri desktop surface, commit-producing delegated work can spawn as create_session sub-sessions. In CLI mode, Squad keeps using the existing task path.
That helps because the delegated work is visible. Before this, a coordinator could delegate work, but the user mostly saw the coordinator summarize what happened. In the App, the delegated work can show up as a real clickable session in the left navigation. “HardCheck validating build” or “DeepBackground researching release” can have its own visible stream instead of being hidden behind one opaque coordinator turn.
This comes with boundaries, which are worth saying out loud. Sub-sessions are for commit-producing work. Pure analysis may still use task. Max depth is one, so this is not a tree of sessions spawning sessions forever. Concurrency should stay around four or five. If the App backend fails, Squad falls back to the task tool. CLI behavior is intentionally unchanged.
A related piece landed earlier in #1148: reasoning effort now threads through charters, config, SDK builders, lifecycle spawning, and fan-out. That lets different agents ask for different effort levels. A security reviewer or architect can request higher reasoning effort while a lighter role stays on auto. Model effort becomes part of the role design instead of one global knob for the whole team.
a leaner coordinator, and skills where Copilot expects them
Another theme in 0.11.0 is prompt weight. Squad’s coordinator prompt had grown because it carried a lot of guidance that was true, useful, and not always needed. In #1311, three large lower-frequency sections were extracted into satellite skills: coordinator-init-mode, coordinator-source-of-truth, and coordinator-response-mode.
That cut squad.agent.md from about 81 KB / 1,137 lines to about 70 KB, a 13.9% reduction. That is not the sort of thing that makes for a flashy demo. It is also the kind of work that makes a system like this easier to keep using. Every session pays for the coordinator prompt. If guidance only matters in certain modes, it should be load-on-demand instead of always-on.
The related change in #1304 moves bundled skills from .copilot/skills/ to .github/skills/. That makes the installed skills visible to GitHub Copilot cloud agent, Copilot CLI outside Squad, VS Code Copilot agent mode, and future Copilot surfaces that understand project-level skills. Again, nobody added a shiny new button. The change makes Squad more Copilot-native and less Squad-private.
state and memory got stricter, which is good
Some of the best work in this release is plumbing. #1251 exposes governed memory tools through the squad_state MCP server: memory.classify, memory.write, memory.search, memory.promote, memory.delete, and memory.audit. Directive and decision writes now route through memory.write where possible.
That is not a visual memory UI. It is a safer contract. Memory should not be “just write files if the tools are not visible.” The prompt now distinguishes local/worktree backends from runtime-owned backends, and #1306 adds a mandatory state-backend handshake so coordinators probe for the state bridge before writing durable state on non-local backends. If the bridge is missing in a non-local setup, the safer behavior is to stop instead of silently corrupting or bypassing state.
There is also a practical release-train fix in #1406. The CLI now pins @bradygaster/squad-sdk to workspace:* for local and prerelease builds, so it resolves to the workspace SDK instead of accidentally pulling an older published package. That sort of bug is hard to spot because it looks like the code in front of you should work, while the running CLI is using something stale. This fix removes that class of failure.
peer squads without inheritance
The release also adds registry support in #1291. squad registry add/list/remove manages .squad/squad-registry.json, and those entries are discovery-only peers. Discovery-only is the important bit. A registered squad is visible to squad discover and can be addressed by delegation, but it does not inherit that squad’s skills, decisions, wisdom, or routing.
That gives multi-repo teams a useful middle ground. upstream is still the inheritance path. registry is peer discovery. You can have a platform squad, a release squad, and an app squad know how to find each other without turning all of them into one large state tree. #1295 adds the cross-squad-communication skill that describes the practical patterns after discovery: synchronous CLI session, read-only metadata scan, async git-based request/response, or issue-based delegation.
The before/after here is intentionally plain. Before, you hand-edited registry JSON and hoped the paths were right. After:
squad registry add platform ../platform-repo
squad discoverThen you pick the communication pattern that fits the work. This is not a hosted cross-squad service. It is a repo-native discovery mechanism with explicit limits, which keeps the feature predictable.
a harder release train
There are other changes in the release that deserve credit even if they do not fit cleanly under one headline. The toolchain moved forward with @github/copilot-sdk 1.0.4, TypeScript 6, Vitest 4, Ink 7, and OpenTelemetry 2.x. CLI help and docs now say “Aspire” instead of “.NET Aspire” in #1239, which keeps the docs aligned with the current name. The green-suite push in #1416 reported 251 test files passed, 1 skipped; 6,972 tests passed, 21 skipped, and 47 todo. Windows and restricted-filesystem hardening followed in #1418, especially around symlink-sensitive observer tests.
This is the part of open-source releases that rarely gets a clean marketing sentence. It is also the part users feel when things stop breaking in strange ways. Command escaping gets fixed. Upgrade paths self-repair. Tests stop lying. Windows paths get less surprising. Local builds use the code you think they are using. None of that is glamorous. All of it is the work.
thank you
So that is 0.11.0: portable teams, cleaner language, sharper Copilot App execution, a leaner coordinator, safer memory, peer discovery, and a release train that got a lot more disciplined. Contributors helped make it real. Squad is growing beyond what I could do alone, and that is one of the best compliments the project could get.
If you are already using Squad, I hope this release makes your setup easier to share and a little less fragile. If you have been watching from the side, squad preset install may be the most practical place to start. And if you contributed to this release, filed an issue, reviewed a PR, or put up with the weird edges while we sanded them down: thank you.