Collaborative AI Engineering: Multi-Agent Development Workspace for Team Alignment

github · Tech · 2026 · source Agentic: yes · promotional bias: med · source-backed · extracted with prompt 0.5.5 (schema v2)

Generated from extraction.json — do not edit by hand. Every claim cites verbatim source evidence; stated means the quote directly asserts the claim, implied means it supports it indirectly.

Problem

Domain: Collaborative software development with AI coding agents

GitHub Next's Ace prototype addresses the gap between fast single-player coding agents and the team alignment, shared context, planning, and review workflows required to build software collaboratively.

Constraints:

Architecture

Ace combines multiplayer chat, cloud-hosted microVM work sessions on isolated git branches, shared agent prompting, live previews, shared terminals, multiplayer code editing, PR creation, model selection, auto commits, session summaries, and dashboard/team-pulse summaries into one collaborative AI engineering workspace.

Diagram confidence: reconstructed (reconstructed from prose).

flowchart LR
  team-members["team members"] --> ace-session-chat["Ace session chat"]
  team-members --> collaborative-plan-editor["collaborative plan editor"]
  team-members --> shared-terminal["shared terminal"]
  team-members --> live-preview["live preview"]
  team-members --> multiplayer-code-editor["multiplayer code editor"]
  team-members --> ace-dashboard["Ace dashboard"]
  ace-session-chat --> microvm-cloud-computer["microVM cloud computer"]
  ace-session-chat --> coding-agent["coding agent"]
  ace-session-chat --> session-summary-block["session summary block"]
  model-picker["model picker"] --> coding-agent
  coding-agent --> microvm-cloud-computer
  coding-agent --> session-summary-block
  microvm-cloud-computer --> shared-terminal
  shared-terminal --> live-preview
  microvm-cloud-computer --> live-preview
  microvm-cloud-computer --> multiplayer-code-editor
  collaborative-plan-editor --> coding-agent
  microvm-cloud-computer --> github-pull-request["GitHub pull request"]
  coding-agent --> github-pull-request
  github-pull-request --> ace-session-chat
  session-summary-block --> ace-dashboard
  ace-session-chat --> team-pulse-summarizer["team pulse summarizer"]
  team-pulse-summarizer --> ace-dashboard
Drag to pan · scroll or use +/− to zoom · reconstructed from the source's described component topology

Components

Component Role Interacts with
team members Engineers, designers, and PMs who discuss requirements, prompt agents, review previews, edit plans, and make decisions together. Ace session chat, collaborative plan editor, shared terminal, live preview, multiplayer code editor, Ace dashboard
Ace session chat Slack-like work session where humans and coding agents share conversation and prompting context. team members, coding agent, microVM cloud computer, session summary block
microVM cloud computer Sandboxed cloud development environment with its own git branch and persistent work state. Ace session chat, coding agent, shared terminal, live preview, multiplayer code editor, GitHub pull request
coding agent Selected LLM coding agent that reads session conversation, changes code, and creates commits. Ace session chat, model picker, microVM cloud computer, session summary block, GitHub pull request
model picker Lets users choose the model used for the agent task. team members, coding agent
shared terminal Allows all session participants to run and see terminal commands in the shared cloud computer. team members, microVM cloud computer, live preview
live preview Displays the running application so the team can inspect agent and human changes together. team members, shared terminal, microVM cloud computer
collaborative plan editor Shared plan surface where teammates edit agent plans before asking the agent to build. team members, coding agent, Ace session chat
multiplayer code editor Real-time shared code editor for manual intervention when agents are insufficient. team members, microVM cloud computer
GitHub pull request Backwards-compatible review artifact created from Ace and linked back to the session. microVM cloud computer, coding agent, Ace session chat
session summary block Continuously updated orientation summary of latest human and agent changes in a session. Ace session chat, coding agent, Ace dashboard
Ace dashboard Aggregates session summaries, unfinished work, recent PRs/issues, and team pulse summaries. team members, session summary block, team pulse summarizer
team pulse summarizer Summarizes coworkers' recent work and uses shared conversations as social context for orientation. Ace dashboard, Ace session chat

Data flow

A team opens an Ace session backed by a microVM and branch, discusses work in a shared chat, prompts the coding agent, watches changes in a live preview and shared terminal, collaboratively edits plans or code when needed, and creates a GitHub PR with a link back to the Ace session. Ace also summarizes recent work, unfinished sessions, PRs, issues, and teammate activity so the same shared workspace becomes context for both humans and agents.

3 supporting quotes
“Each session is more than a chat channel. It is also backed by a microVM, so a sandboxed computer in the cloud on its own git branch.”article, stated
“both prompt the agent. It’s multiplayer prompting. The agent can also read our whole conversation - that’s all input to the prompt. This kind of accessible Slack-like interface with access to a coding agent means that everyone involved in creating software - not just developers, but designers”article, stated
“We can create this PR from directly inside Ace. We can open it on GitHub. It has a link back to our Ace session.”article, stated

Why this architecture

Ace puts chat, planning, code execution, preview, and GitHub handoff in one shared cloud workspace because agentic development collapses implementation time and moves the bottleneck to early, continuous team alignment.

3 supporting quotes
“to happen constantly, alongside the implementation. Planning and building are no longer separate phases. They’re a continuous cycle. The tools of the future need to bring planning, context-gathering, decision-making, and development under one roof. This is especially true because most of the”article, stated
“The tools of the future need to bring planning, context-gathering, decision-making, and development under one roof.”article, stated
“None of our current tools give teams a shared space to discuss plans, gather the right context, and work with agents as a collective.”article, stated

Models used: Claude Opus 4.6 · coding agents

Scale

Alternatives considered (roads not taken)

Solo terminal agents on individual machines

Rejected because: They scale individual output while hiding plans, prompts, and context from the team.

“developers. The main problem with this dream is it assumes software is made by one person. All these tools are single player interfaces. And they focus on scaling up the work of the individual. But there is limited value in scaling up an individual. Because”article, stated
“Unhelpfully, most current coding agents have a local plan mode that is unshared with others. So you’re not even checking with your team on whether the plan is good before you ship it off to the agent. And we lose more alignment points. This leaves the poor”article, stated

Use pull requests as the main alignment checkpoint

Rejected because: PR review happens after implementation, when code has already been generated and context is missing.

“This leaves the poor pull request to carry the weight of all those checkpoints at the very end of the process when it’s too late.”article, stated

Coordinate agentic work in existing tools like Slack, Jira, Linear, issues, and PRs

Rejected because: The talk argues those primitives were built for slower software development and cannot handle agentic work's speed and volume.

“GitHub, Slack, Jira, Linear, and the like, as they currently stand, are not designed for the agentic development world.”article, stated
“The PR and the issue are the wrong primitives that can’t handle the speed, shape, and volume of agentic work. I know I work at GitHub so that might sound heretical, but I promise it’s not controversial for me to say it. Very few people internally believe”article, stated

Use Slack alone as the collaboration interface

Rejected because: Slack lacks software-development primitives such as cloud execution, preview, code editing, and PR integration.

“If you’re thinking, why not just use Slack? It’s because Slack is never going to become a fully featured software development tool.”article, stated
“Slack? It’s because Slack is never going to become a fully featured software development tool. It doesn’t have the right primitives, and it’s not going to add them. Ace is explicitly for software development, but is more welcoming to other team members than your terminal. Anyway, back”article, stated

Require teammates to pull branches and manage local worktrees to collaborate

Rejected because: Ace lets teammates jump into a shared cloud session and see current work and prompting history immediately.

“no one has to stash their git changes and pull down a branch, or wrangle any local worktrees. I just jump into their session, and see what they’re up to. Including their whole prompting history with an agent to understand how they arrived at the current”article, stated
“I just jump into their session, and see what they’re up to. Including their whole prompting history with an agent”article, stated

Patterns

human-in-the-loop-gate (collaboration)

Ace moves human alignment before and during agent execution through shared plans, chat, previews, and PR review.

“We need tools that help everyone on the team align before the agents start working, not after.”article, stated
“I can see all my teammates cursors. We can collaboratively edit it together.”article, stated

tool-use-orchestration (agent-runtime)

The coding agent operates inside a workspace with terminal commands, preview, git commits, model selection, and PR creation rather than a bare chat box.

“Just like a local machine, I can run terminal commands in a session.”article, stated
“The agent has automatically made a commit for me with a nice readable commit message.”article, stated

multi-agent-orchestration (collaboration)

Ace is designed around humans working with multiple coding agents and shared sessions rather than disconnected solo agent terminals.

“I have my teammates in here and we can talk about the work we’re doing, but I also have my coding agents in here.”article, stated
“This is no longer a bunch of solo disconnected terminal instances on individual computers.”article, stated

context-compaction (context-management)

Ace summarizes session changes and team activity so developers can regain orientation across many parallel workstreams.

“We have this handy summary block in the top right that is always up to date with the latest changes in this session”article, stated
“This dashboard is our first pass at making agents proactive in bringing that context to you.”article, stated

durable-execution (runtime)

Ace keeps sessions running in cloud microVMs so work can persist after a developer closes their laptop.

“I can close my laptop and work can continue. My session doesn’t die.”article, stated
“I just talk to my always-on Ace agent in the cloud. For bigger, more complex features, you’ll want the agent to write a plan.”article, stated

observability-tracing (reviewability)

Prompting history, session summaries, diffs, commits, and PR links provide a reviewable trail of agent work.

“Including their whole prompting history with an agent to understand how they arrived at the current state of things.”article, stated
“I can open the diff to make sure it’s implemented the way I want.”article, stated

Tradeoffs

Use cloud microVM sessions as the unit of collaboration.

Chose Always-on sandboxed cloud computers on isolated git branches over Local laptops, branches, worktrees, and terminal instances.

Rationale: MicroVM sessions let teammates join instantly, see history, share previews/terminals, and keep work alive after a laptop closes.

“It is also backed by a microVM, so a sandboxed computer in the cloud on its own git branch.”article, stated
“I can close my laptop and work can continue. My session doesn’t die.”article, stated

Integrate collaboration and development primitives in Ace.

Chose Slack-like chat plus cloud computer, agent, terminal, preview, code editor, and PR integration over Coordinating across separate Slack, terminal, IDE, browser, and GitHub surfaces.

Rationale: The talk argues alignment has to happen alongside implementation rather than across fragmented tools.

“It’s a bit like Slack, GitHub, Copilot, and a bunch of cloud computers had a baby.”article, stated
“planning and discussion that would otherwise happen in Slack or GitHub issues, is now happening in our sessions.”article, stated

Keep GitHub PRs in the loop.

Chose Create PRs from Ace with links back to sessions over Replacing GitHub review entirely.

Rationale: Ace preserves compatibility with existing code-review infrastructure while adding earlier shared context.

“Because eventually all this code has to go back to GitHub. We can create this PR from directly inside Ace. We can open it on GitHub.”article, stated
“It has a link back to our Ace session. This is all backwards compatible.”article, stated

Let non-developers participate directly in agent prompting.

Chose Accessible shared chat with agent access for designers and PMs over Developer-only terminal interfaces.

Rationale: Product and design context matters before code is generated, so non-engineers need to be in the same agent conversation.

“everyone involved in creating software - not just developers, but designers and PMs - can all be in the same conversation”article, stated

Prompt the agent from collaboratively edited plans.

Chose Shared plan editing before build execution over Private local plan mode.

Rationale: Team-edited plans preserve alignment before the agent starts implementing.

“I can see all my teammates cursors. We can collaboratively edit it together.”article, stated
“once we’re happy with all the details, we can go back to chat and ask Ace to build this and off it goes.”article, stated

Gotchas (what bit them)

Agentic speed can remove early alignment touchpoints.

Root cause: The implementation window collapses to minutes, making teams feel they can skip planning before prompting agents.

Resolution: Move planning, context-gathering, and decision-making into the same workspace as implementation.

“But that implementation window has collapsed. And because implementation is no longer as expensive and time-consuming… …we think we don’t need to plan as much.”article, stated
“Code is so cheap we don’t properly stop to think before prompting it.”article, stated

PRs become overloaded as the late alignment checkpoint.

Root cause: Plans and context stay local until the agent has already written code.

Resolution: Expose planning and work-in-progress in shared sessions before PR creation.

“This leaves the poor pull request to carry the weight of all those checkpoints at the very end of the process when it’s too late.”article, stated
“So you’re not even checking with your team on whether the plan is good before you ship it off to the agent.”article, stated

Agent work creates coordination debt when multiple people assign overlapping tasks.

Root cause: Disconnected agent sessions hide who is changing which files or features.

Resolution: Use shared sessions, team pulse summaries, and visible prompting histories to show what work is underway.

3 supporting quotes
“Hairy merge conflicts - multiple agents touching the same files”article, stated
“Duplicated work - you and another engineer assign agent to the same feature”article, stated
“On the right, we have a Team Pulse section that summarises what my co-workers have been up to over the last couple of days.”article, stated

Agents cannot infer the non-code context that determines good product decisions.

Root cause: Business context, politics, product vision, user research, support insights, and organizational history live in people's heads.

Resolution: Create a shared social workspace where humans surface that context naturally and agents can read it.

“most of the context you need for alignment isn’t in the codebase.”article, stated
“you’ve built before. …all matter immensely when you’re deciding what the right thing for your team to build is Agents can never discover this context on their own. You need a way to get humans to share it early and naturally, without adding process and overhead All of this has been very clear”article, stated

Cloud agent collaboration still needs manual code escape hatches.

Root cause: The speaker says agents remain weak for some frontend design/CSS work.

Resolution: Keep VS Code and real-time multiplayer code editing available in the shared microVM.

“And sometimes you still need to touch code. I find this is still true for front-end design work. Agents are shit at CSS.”article, stated
“We have real time, mulitplayer code editing with everyone in that session.”article, stated

Evaluation

Ace is described as a research prototype entering technical preview, so the source gives qualitative demo evidence and planned user testing rather than production metrics.

Metrics: technical preview with a few thousand people · qualitative collaboration learning · ability for multiple teammates to prompt one agent · shared preview and terminal usability · orientation through summaries and team pulse

3 supporting quotes
“It’s not a prime time product yet. So if it looks a pretty rough around the edges, it’s because it is.”article, stated
“We’ll be user testing it with a few thousand people to learn more about how people collaborate in it, and iterate from there.”article, stated
“Ace is explicitly for software development, but is more welcoming to other team members than your terminal.”article, stated

Outcomes

The source reports Ace entering technical preview with a few thousand users, and frames the problem around teams moving from one feature per day to five features per day, but does not report production adoption or quantitative impact.

3 supporting quotes
“we’ve been building a new research prototype to explore how we might solve these problems. It’s called Ace.”article, stated
“We’re about to go into technical preview. We’ll be user testing it with a few thousand people to learn more about how people collaborate in it, and iterate from there.”article, stated
“This becomes a living intelligent environment where everyone shares the same workspace and context.”article, stated