the github copilot app and agentmash: use both.

published 2026-10-17

the GitHub Copilot app runs agent sessions in parallel, and Agent HQ adds Claude and Codex inside GitHub. agentmash tells the Copilot CLI, Claude Code or Cursor (and, per VS Code’s docs, Copilot in VS Code’s Local sessions) before an edit when a teammate’s agent changed that file in the last 30 minutes or on an unmerged branch.

how the github copilot app runs agents in parallel

GitHub made the Copilot app generally available on June 17, 2026, for macOS, Windows and Linux. you start a session from an issue, a pull request or a prompt, and run several at once across repositories, each on its own branch and worktree. when one is done, you review the diff, try it in the app’s terminal and browser, and open a pull request that goes through your team’s existing checks and merge requirements.

GitHub’s session docs give three places to run a session: a new working tree, your local repository, or a cloud sandbox hosted by GitHub, which is in public preview. three modes set how far the agent goes on its own. Interactive waits for your input, Plan has you approve a plan before the agent carries it out, and Autopilot writes code, runs tests and iterates without waiting for input. the docs credit the isolated workspace with letting several tasks move in parallel without conflicts, and say the app is built on the GitHub Copilot CLI.

that isolation is what git worktrees do for parallel agents: sessions in their own working trees stop writing into the same files on disk. two branches still meet somewhere, and in this flow it’s the pull request. keeping your own sessions apart stays the worktree’s job, since agentmash doesn’t warn your own agents about each other.

what github agent hq adds: mission control, claude and codex

GitHub announced Agent HQ at Universe on October 28, 2025. its first piece was mission control, which GitHub describes as “a single command center to assign, steer, and track the work of multiple agents”, with one interface on GitHub, in VS Code, on mobile and in the CLI.

Claude and Codex arrived as coding agents on February 4, 2026, for Copilot Pro+ and Copilot Enterprise, and on February 26 for Copilot Business and Copilot Pro. you start one from a repository’s Agents tab, by assigning it an issue, from GitHub Mobile, or from VS Code 1.109 and later. they work asynchronously and open draft pull requests for review, you ask one for changes with @claude or @codex in a pull request comment, and one issue can be assigned to Copilot, Claude and Codex at once.

GitHub’s third-party agents page still lists them as a public preview, and says the Claude agent uses the Claude Agent SDK and the Codex agent the Codex SDK, and that both agents can be powered by your existing Copilot subscription. the Agent HQ announcement says enterprise admins can control which agents are allowed and define access to models. per the February 26 post, all agent activity runs within GitHub’s enterprise controls, with audit logging through the Agent Control Plane.

what github shows the rest of your team

GitHub does put agents’ work in front of a team. per its page on managing agent sessions, a session of the Copilot cloud agent (formerly known as Copilot coding agent) is shared by default: it shows in the All sessions view of the repository’s Agents tab, for anyone with access to the repository. a local session, from the Copilot CLI, VS Code, JetBrains or the Copilot app, stays unshared until its owner shares it, and then collaborators can read its prompts, responses and file changes, view-only.

when two branches do conflict, GitHub helps there too. since March 26, 2026, on paid Copilot plans (on Business and Enterprise, once an admin has turned on the coding agent), you can mention @copilot on a pull request and ask it to merge in main and resolve the conflicts, and it checks that the build and tests still pass before it pushes. the Agent HQ announcement listed one-click merge conflict resolution too.

the Copilot app has its own step at the pull request, Agent Merge, which you start from the pull request’s options in the app. you choose the actions it may take, such as addressing review feedback, helping resolve CI failures or handling merge conflicts, and it watches the pull request through review and CI. once the required checks pass, you choose whether to merge.

what github’s docs don’t describe

read on 2026-10-16, ahead of GitHub Universe on October 28 and 29, 2026, GitHub’s docs for the Copilot app, Agent HQ, agent sessions and hooks don’t describe the three cases below.

• your agent told, before it edits, what a teammate’s agent is changing. sharing puts a teammate’s session in front of people, in the Agents tab, and Copilot Memory shares facts about a repository, such as its conventions and build commands, with everyone who uses it there. the docs describe no step where a teammate’s change in progress reaches another developer’s agent while that agent works.
• a teammate’s change to a function your file imports. their agent changes the signature of createUser in src/models/user.ts on one branch; yours, in src/api/handlers.ts on another, keeps building against the old one. the two branches share no file, so git finds nothing to conflict. if a build or a test catches it, it does so after both changes are written.
• agents outside GitHub’s own surfaces. the sessions GitHub lists are those of agents running on GitHub (the Copilot cloud agent, Claude and Codex) and the local ones their owners share, from the Copilot CLI, VS Code, JetBrains and the Copilot app. a teammate working in Cursor, Gemini CLI or Claude Code in a terminal isn’t among them.

GitHub’s tools coordinate the agents you direct: you assign them, steer them and review what they open. agentmash tells each developer’s agent what their teammates’ agents are changing.

what github copilot gets from agentmash

GitHub Copilot is one of the agents npx agentmash login connects, and it runs the same hooks as Claude Code. the login puts agentmash’s hooks in one file, ~/.copilot/hooks/agentmash.json, in the format VS Code and the Copilot CLI both read. it puts agentmash’s MCP server in ~/.copilot/mcp-config.json, the Copilot CLI’s user configuration for MCP servers, and adds it to VS Code with code --add-mcp when code is on your PATH, or prints the line to run when it isn’t. all of it is in your home directory, never in a repository.

PreToolUse

before an edit, it checks the room. if a teammate’s agent wrote the same file within the conflict window (30 minutes by default) or on a branch of theirs that isn’t merged yet, or, in JavaScript and TypeScript, within the window changed a symbol your file depends on anywhere in the repo, the advisory goes into the Copilot CLI agent’s context as a note, graded by severity. VS Code’s Local hooks reference says its agent takes it the same way, as context for the model. the edit goes ahead.

PostToolUse

reports each edit to the room, with the exported symbols it changed, in the background.

UserPromptSubmit

sends the first 500 characters of your prompt as a task hint, so each event says what you’re doing, not only which files. AGENTMASH_HINTS=0 keeps yours on your machine, except what a lobby session you share is on.

Stop

as the agent finishes its turn, if a file this session edited was also edited by a teammate’s agent in the last hour by default, or on their branch that isn’t merged yet, the hook writes a note once, with whose change it meets, unless the room has reconciliation off (agentmash reconcile off). it only advises: the agent finishes as it would have, and a person decides what happens to the two changes.

the MCP server

lets Copilot ask the room while it plans: who is working on what, whether anyone has touched a file, which files are contested, and claims, to split the work before anyone writes.

agentmash’s Copilot hooks have no session-end event, since VS Code’s Local harness has none, so the board shows a Copilot session as silent once it goes quiet, never as ended.

VS Code’s hooks experience is a preview, and its Local harness runs these hooks while chat.useHooks is on, which it is by default. the same page says a session’s Session Target picks its harness (Copilot, Local, Claude, Codex or Cloud), that the Local harness reads user hooks from ~/.copilot/hooks/*.json, and that what it documents for the Local harness doesn’t automatically apply to other harnesses. agentmash’s docs describe the Local target, and don’t describe the Copilot harness, the one VS Code’s agent harnesses page suggests starting with. a VS Code session sent to the Cloud target is one of the tasks that run on GitHub, outside what the login connects.

agentmash needs VS Code 1.109 or newer, or the Copilot CLI 1.0.86 or newer. how each coding agent was checked, as of 2026-10-05: the warning before an edit and the reports were tested live in Claude Code, Codex, Cursor, GitHub Copilot (its CLI), Kilo Code and OpenCode, and the MCP tools in Claude Code and Codex; Amp, Cline, Crush, Factory Droid, Gemini CLI, goose, Kiro, OpenHands and Qwen Code are held by our tests against payloads recorded from each tool, not run live yet; Devin, Antigravity, Junie, Continue and Zed rest on their own docs (Devin and Junie partly on our tests too), not tested live yet.

which copilot surfaces agentmash reaches

in the app, GitHub’s docs say, MCP servers configured for the Copilot CLI are available, and plugins can add hooks, along with skills, custom agents and MCP servers. GitHub’s hooks reference names two surfaces that run hooks, the Copilot CLI and the Copilot cloud agent. agentmash’s docs cover GitHub Copilot in VS Code and in the CLI, and don’t describe the app, so this page doesn’t say what an app session gets from agentmash.

sessions that run on GitHub are outside what the login connects. the hooks reference’s section on the cloud agent says a job starts with only the repository’s .github/hooks/*.json, without user-level hook files, and reaches only GitHub and Copilot hosts unless an admin allows more. a login writes user-level files on a developer’s machine, so the hooks it installs aren’t in that job.

agentmash’s docs don’t describe connecting the cloud agent, a cloud sandbox, or Claude and Codex sessions started on GitHub. the Copilot cloud agent’s sessions are shared with the repository in GitHub’s session list; the sharing docs don’t say the same of a Claude, Codex or cloud-sandbox session, and the team sees any pull request one opens.

agentmash has a desktop app of its own, agentmash lobby, for macOS and Windows: your coding agents side by side on your own logins, with your team’s sessions next to yours. this page is about the hooks the login installs, which are what tell an agent before it edits.

what you’re told when two changes meet

a teammate’s agent works in their own clone, on their own machine, often on a branch of its own. when your agent is about to edit a file their agent changed on another branch within the conflict window, 30 minutes by default, it’s told before the edit, as a PARALLEL EDIT. there’s nothing to re-read, so the advisory asks the agent to keep its edit additive, not to reformat or reorder, and to name any divergence in its reply.

past the window, work on a teammate’s own branch that hasn’t merged is still said. the room remembers it by person, branch and file for up to a week (less when the room keeps less history), until the branch merges. your agent hears of each such change once a session, and not at all when your checkout already has their commit.

the default branch, and the usual names beside it such as develop, are nobody’s unmerged work, so with the default 30-minute window, and main as the room’s default branch, a teammate’s change on main two hours ago isn’t said before an edit. a room’s admin can turn this memory off. what counts as a conflict has the rest.

if both changed the same file anyway, say alice’s agent on main and yours on feat/login, both in src/models/user.ts, this is the note the Stop hook writes as your agent finishes its turn, word for word. the hook hands it over as a systemMessage, which VS Code’s Local hooks reference says is shown to you as a warning. for the Copilot CLI, GitHub’s reference for the stop hook documents only a decision and a reason, so this page doesn’t say how the CLI shows the note.

[AgentMash: OVERLAP] A file this session changed was also changed by alice@example.com,
so a person decides how the two changes come together: nothing was stopped, merged or
committed for either side.
• src/models/user.ts — also changed by alice@example.com.
  alice@example.com: last write 9 min ago on branch main — you are on feat/login
  while working on 'soft deletes' (+12/-3 lines, touching User, deletedAt).
  You both touched User — that is where the two changes are most likely to meet.
  Your side: 'add a login endpoint' (+8/-1 lines).
Look at both changes with alice@example.com before either one lands.

nothing is merged, pushed or opened for you. the pull request, and GitHub’s conflict tools, are still where the two changes come together.

side by side

GitHub’s column is from its docs, blog and changelog, read on 2026-10-16.

when the copilot app is enough, and when to add agentmash

• you alone, running several sessions: the Copilot app’s worktrees keep them apart, when each session starts in a new working tree. agentmash adds nothing here, since it doesn’t warn your own agents about each other.
• a team on one repository, all on GitHub Copilot: the app or Agent HQ for each developer’s own sessions. agentmash for the Copilot CLI, and per VS Code’s docs for Copilot in VS Code’s Local sessions: each of those agents is told, before it edits a file, when a teammate’s agent that the login connected changed it within the conflict window or on a branch of theirs that hasn’t merged. agentmash’s docs don’t describe the Copilot app, so what a teammate’s app session reports isn’t known here, and work handed to GitHub’s agents shows in GitHub’s session list, not in the room.
• a team on mixed tools: one developer on the Copilot CLI, one in Claude Code, one in Cursor. GitHub lists the sessions of agents running on GitHub and the local ones their owners share. in a connected repository, each edit from the agents whose hooks the login connects, Copilot, Claude Code and Cursor among them, goes to one room for the repository.
• work you hand to GitHub’s own agents: the cloud agent’s sessions show up in the repository’s session list, and the pull requests that Claude, Codex and the cloud agent open show to the team. that stays GitHub’s view.

set it up beside the copilot app

1. someone who can push to the repository connects it once, at agentmash.dev/install: they sign in with GitHub and pick it. nothing is committed to it and there is no pull request.
2. each developer runs npx agentmash login once on each machine (Node.js 18.12 or newer), signs in with GitHub in the browser it opens, types the code the terminal shows, and restarts their coding agent. it connects the coding agents it finds, GitHub Copilot in VS Code and the Copilot CLI among them, in their own settings on that machine, for each connected repository they can push to.

what that means for a session in the Copilot app isn’t in agentmash’s docs. npx agentmash logout takes it all back out. step by step, with a prompt to paste into Copilot: set up github copilot.

what it doesn’t do

• it warns about teammates’ agents, never your own. two sessions of yours, in two worktrees or in one checkout, both report as you, so neither is warned about the other. keeping them apart is the worktree’s job.
• an advisory is not a lock: it informs the agent, and the edit goes ahead. AGENTMASH_STRICT=1 is the setting that blocks.
• agentmash never merges, pushes or opens a pull request, and it doesn’t resolve conflicts. a person, or GitHub’s tools, does that.
• symbols are read from the JavaScript and TypeScript family only. Python, Go and Rust files are matched by path alone, so a break across files in them goes unseen.
• a symbol match looks back over the conflict window only, 30 minutes by default. the room’s memory of a teammate’s unmerged branch, kept for up to a week, is by file, so the warning about their change to createUser two hours ago reaches your agent before an edit only when it edits src/models/user.ts itself; asked through the MCP tools, who_is_working_on_what still lists that work.
• in a Copilot CLI session with its sandbox on, hooks run inside the sandbox with the agent’s shell access (GitHub’s hooks reference), and VS Code says an organization might restrict which hooks can run. agentmash’s docs don’t cover either case; a hook that can’t reach the room lets the edit go ahead and says nothing.
• a check that runs past its budget, 1500 ms by default, lets the edit go ahead unwarned.
• the room gets who made each edit, file paths, branch names, the shape of each change (its line counts and the names it touches), the first 500 characters of each prompt and an opaque id of the checkout each edit came from. teammates’ agents read those prompts in their context, so keep secrets out of prompts. your code stays on your machine unless your room turns diffs on, or you share a session live. what leaves your machine lists all of it.
• with VS Code’s chat.useClaudeHooks setting on (it’s off by default) and agentmash’s Claude Code hooks installed on that machine, a Copilot edit in VS Code’s Local harness is reported twice. leave it off, or take Copilot out with npx agentmash tools remove copilot.

the github copilot adapter →the five levels →what counts as a conflict →reconciliation →known limitations →