Back to Explore
NewsVibeFix editorialUpdated Nov 20, 2026

Cursor Projects Goes Multiplayer: Your Agent Fleet Can Now Talk to Your Teammates' Agents

Cursor made Projects multiplayer on November 10: teammates join one Project with their own coordinator and agents, sharing a task board and one Agent Store. Agents can now message each other directly — but the launch blog gives no effectiveness numbers, and shared context still has no governance rules.

Cursor's official Projects diagram: Engineer, Designer, and PM each direct a Coordinator, the coordinators talk to each other, and agent fleets share one context.

The agent fleet can finally work as a team

On November 10, Cursor announced that Projects is now multiplayer. The blog post has a simple title: "Cursor Projects is now multiplayer." Back in September, Cursor launched Projects, letting one engineer direct a fleet of agents through a single coordinator to take on large bodies of work — a feature, a migration, even a whole app. Two months later, this upgrade changes the unit of Projects from one person to a whole team: invite your teammates into a Project, and you plan, build, and ship together, each with your own agents alongside you.

It is worth distinguishing this upgrade from the September launch, which this site already covered. That launch was about "one person directing a fleet of agents"; this one is about "several people, each with their own fleet, collaborating inside one Project." Reading only the headline, you might mistake it for a small patch — an invite button added to a solo tool. In fact, Cursor changed the basic structure of Projects: context moves from personal to team-shared, agents move from listening to one person to talking to each other, and the task board moves from a personal to-do list to a board the whole team shares. Those three changes together turn Projects from "a superpower for one person" into "a workspace for a team."

One sentence in the blog is worth quoting in spirit: "Multi-agent systems have so far served one person. Projects is a multi-agent system built for a whole team." The implication is that the competition in agent tooling is shifting: for the past two months it has been about how much work one agent can do, and from now on it will be about whether several people's agents can work together. Whether that judgment holds up depends on how it behaves in practice — the limitations come later in this article — but the direction itself is worth recording: AI coding tools are moving from personal productivity to team collaboration.

Cursor's official Projects diagram: Engineer, Designer, and PM each direct a Coordinator, the coordinators talk to each other, and agent fleets share one context.

From one person to a team: what changed structurally

Start with what a Project actually looks like in multiplayer mode. Each person who joins still gets their own one-to-one chat with their coordinator and worker agents, each with its own local context. On top of that, the Project adds two layers shared by the whole team. The first is a shared task board: who is doing what, what everyone's agents are working on, and the pull request behind each task, all visible to the team on one board. The second is shared context: requirements documents, diagrams, tech specs, mockups — built once, then growing with the team's work. A decision made in one chat becomes accessible to every agent in the Project.

That structure solves a concrete pain point: agent context has always been siloed per person. When someone new joined a team, they had to brief their agent from scratch — project background, code conventions, past mistakes — before it could do anything useful. In a Project with shared context, a new teammate is invited into context that is already configured and up to date, with no repetitive setup. Cursor's blog gives an on-call example: several of its own teams now run on-call rotations in a shared Project. When one engineer recently took over the rotation from a teammate, their coordinator picked up right where things stood, after checking in first. It already knew what work was in flight, which issues were still unattended, which incidents and notes needed handing off, and which channels, Linear boards, and threads to keep an eye on. In-progress work can even be handed over directly: the new person's agent simply takes it on.

There is another, easily overlooked effect of combining the task board with shared context: humans and agents look at the same picture. Previously, the project manager looked at a Linear board, the engineer looked at their own chat history, and the agent looked at its own context — three views that never quite lined up. Now the board says who is doing what and which pull request sits behind it, and humans and agents alike read the same live state. That sounds unremarkable, but in multi-person, multi-agent collaboration it is the precondition for avoiding duplicated work and stepping on each other's changes.

Shared context: the team's real asset

Shared context is the part of this upgrade most worth unpacking, because it changes the answer to the question "whose property is context?" According to Cursor's official documentation, agents in a Project use two stores. The first is the Project store, at /cursor/stores/self, shown as Context in the app, which every member's agents read and write. The second is each person's personal store, at /cursor/stores/user, which belongs to you alone: your preferences and skills live there, follow you between Projects, and are never seen by your teammates' agents. Your coordinator can offer to copy entries from your preferences that describe how to work in this Project into the Project's rules — but only the entries you approve.

That two-layer design matters. Without a personal store, sharing would be leaking: your private preferences, your personal skills, and whatever you keep in your personal store would be open to your teammates' agents. With the boundary drawn clearly, sharing and privacy have a line between them: what the Project needs goes in the shared layer; what belongs only to you stays in the personal layer. The clearer that line, the more willing a team is to put real material into shared context. If the line were fuzzy, team members would instinctively keep anything sensitive out of the shared layer, and shared context would slowly become an empty ledger nobody dares to write honest things in.

Shared context also carries a natural risk: pollution. A decision someone jotted down wrong in their own chat, an outdated technical approach, an agreement that no longer holds — once any of these enters shared context, every agent on the team will treat it as fact. Cursor's design includes one mitigation: a decision is made in someone's chat, but it only reaches all agents once it enters the shared layer. What the blog and the documentation do not explain is whether entering the shared layer is automatic or requires a human confirmation, nor how a team cleans up or rolls back shared context once wrong information gets in. For a small team, that may be the first rule to write down before using the feature seriously: who is allowed to write into shared context, and who is responsible for fixing it when it is wrong.

Agents can now talk to each other directly

The second door that a shared workspace and shared context open is direct communication between teammates' agents. Previously, if your agent wanted to know what your teammate was doing, you had to ask your teammate and relay the answer. Now coordinators can message each other directly, planning around and unblocking each other in real time, without a human in the middle. Cursor's blog gives two examples. First: an engineer is adding reviews to the product page while a designer is redesigning it; their coordinators spot the overlap early and sync up, so the reviews are built straight into the new design, with no refactors down the road. Second: your feature reads from a database while your teammate is changing the schema; your agents agree on the order of work up front, so neither of you hits a merge conflict at the end.

Both examples share one property: the conflict is caught before anyone starts building, not exposed at merge time. In traditional development, these conflicts are prevented by standups, documents, and human memory — and every miss costs a round of rework. Agents talking directly moves conflict prevention out of human process and into something machines watch continuously. The premise, of course, is that both coordinators genuinely spot the overlap and genuinely reach agreement. The blog does not say what happens when two coordinators disagree, or when one misunderstands the other's intent and syncs the mistake to the whole team. That is the part of the beta most in need of real-world verification.

The safety mechanisms are the part of this section most worth reading closely. According to the official documentation, Cursor holds agent-to-agent messages to three rules. First, messages are labeled as agent input: the receiving agent is told which teammate's agent sent the message, treats the text as untrusted input to weigh rather than as an instruction from the person it serves, and asks before sharing that person's personal files or connector data. Second, your chat is not interrupted: a teammate's message goes to a side chat forked from your chat, called "Chat with {name}'s agent." It answers from what your chat knows, its reply goes back to the sender's chat, and your chat gets a note about the exchange on its next turn. Third, side chats only answer: you can read, stop, or archive a side chat, but you cannot message it; it never shares secrets, credentials, or tokens; it can read the task board but not change it; and it cannot ask you questions, request access, connect source control, or manage routines.

Taken together, those three rules mean agents can compare notes, but the channel they use is restricted, one-directional, and auditable. Your agent will not hand your private files to someone else because another agent said so in one sentence, and your conversation will not be interrupted mid-flow by a teammate's agent. The design shows Cursor thought clearly about the risk: in multi-person, multi-agent work, the danger is not that agents are too dumb, but that they are too proactive. Draw the boundary for initiative first, then talk about the efficiency of collaboration.

Billing and access: who pays, who gets in

The two most practical questions in multiplayer mode are money and access. The billing answer is stated plainly in the official documentation: each person who joins gets their own chat in the Project, and "their chat runs and bills as them." The tokens your coordinator and worker agents burn are charged to you; your teammate's are charged to them. That avoids the most common team dispute: one person letting an agent run wild on a large task and the bill being split across the whole team afterward. Everyone pays their own way, and responsibility follows the same split. If a team lead wants to control costs, the lever is who is allowed into the Project, not how the bill is divided after the fact.

Access has its own set of limits. First, Projects are shared within a Cursor team, and joining takes an invite — someone on a personal account, or on another team, cannot join. The flow is: click Invite at the top of the Project, search for teammates by name or email, send the invite, and the teammate clicks Accept Invite on the Project's invite card to get their own chat. The owner and anyone who has joined can invite others. People can also join from the Project's link, but only people in the Project can copy it, and the owner can choose Reset Share Link to stop earlier copies from working. Second, a teammate needs access to the Project's repository to join; without repository access, they cannot get in. Third, joining is not available in three cases: with Privacy Mode (Legacy), on a Project that runs on a self-hosted machine, or on an archived Project.

The rules for leaving and removal are equally direct: to stop working in a shared Project, open its menu in the sidebar and choose Leave Project, and you can rejoin later from an invite or the link; the owner can remove anyone else from the invite menu. None of this is elaborate, but it covers the basics of team collaboration — who gets in, who can invite, who can remove, and what happens when a link goes stale. That is enough for a small team. A larger team with compliance requirements may also want audit logs and tiered permissions, which the blog does not mention.

The numbers this launch did not include

Compared with the September launch, there is a conspicuous difference in this multiplayer announcement: it contains no numbers at all. When Projects launched in September, Cursor gave a specific claim: new users who adopted Projects merged 30 percent more pull requests, and engineers who primarily relied on it merged six times as many. Both figures came from Cursor measuring its own user base, with no independent audit — but at least they gave readers an anchor to argue about. This multiplayer post has nothing comparable: no figure for fewer conflicts, less rework, or faster handoffs. The only "evidence" is the on-call handover story from Cursor's own teams, not a measurement from external users.

That is not an accusation that Cursor withheld numbers; it is a reminder that the real-world effect of this upgrade currently has no quotable data behind it. You can believe the design is pointed at the right problems — shared context, agents talking to each other, a shared task board, each aimed at a genuine pain point — but "the design is right" and "it actually saves time in use" are two different things. The on-call story sounds smooth, but it comes from Cursor's own engineers, on their own codebase, with the tool they know best. Whether the same flow works as smoothly for a different team, a different codebase, and members less familiar with agents is still unanswered.

One more marketing line deserves to be read at a discount: "Projects is the first workspace where software teams work side by side with all of their agents." That is Cursor's own framing, not an industry consensus. Other tools are moving in the same direction from different starting points — some from chat, some from code review, some from task management. Cursor's advantage is that it holds the editor, the cloud agents, and Projects together in one product — but the word "first," in a race this competitive, is best read as the vendor positioning itself, not as a statement of fact.

What it means for a small team

If you are a team of two or three people working on a feature that spans several pull requests, a framework migration, or a project that needs long-term care, multiplayer Projects is worth trying right away. Its value is not that the agents got smarter, but that the team no longer has to brief each agent separately. Where everyone used to explain the project background to their own agent, now it is explained once and shared by the whole team; where handoffs used to rely on documents and spoken briefings, an agent can now pick up in-progress work directly; where cross-functional conflicts used to surface in meetings, agents can now sync up before anyone starts building. The time saved is not coding time — it is the most grinding part of team collaboration: alignment, handoffs, and rework.

There are also cases where switching right away is not worth it. First, if you develop alone, or your team is two people who sit together and align verbally at almost no cost, the gains from multiplayer may not cover the learning and setup cost. Second, if the work in your Project is small — one change, one pull request — the coordinator's overhead can outweigh the task itself. Third, if your team has not yet agreed on rules for shared context — who can write to it, who fixes it when it is wrong, how often it gets cleaned up — shared context can quickly become a ledger that only gets messier over time.

One more practical suggestion: start with one concrete scenario rather than moving the whole team's work in at once. On-call rotation is the example the blog gives, and it is also the best place to start — handoffs are frequent, context matters, and the cost of getting it wrong is visible. Run on-call through it for two weeks, see whether handoffs genuinely get smoother and agents genuinely ask fewer repeated questions, and only then decide whether to move feature development and migrations in too. The best way to use a tool in beta is small, verified steps — not an all-in bet.

Three things the blog did not say

First, effectiveness data. At the September launch Cursor gave pull-request comparisons; this multiplayer release gives no effectiveness numbers at all — no conflict-reduction rate, no rework-reduction rate, no handoff speedup. The only example is the on-call story from Cursor's own team. Real results will only be known once outside teams have used it for a while.

Second, pricing changes. The blog does not say whether multiplayer changes how billing works; the documentation only states that each person's chat bills as them. Team plans, seat fees, and usage caps are not covered in either place. If you are already on a Cursor team plan, check your plan's usage rules before deciding how many people to bring into a Project.

Third, governance of shared context. The blog explains what shared context is and why it helps, but not what happens when something wrong gets written in, how stale entries get cleaned up, or who has the authority to change it. In multi-person, multi-agent collaboration, the quality of shared context decides the quality of the whole system — and that part of the rules is currently blank, so teams need to write their own first.

Back, finally, to the line about "a multi-agent system built for a whole team." If that claim holds, it means competition among AI coding tools is changing tracks: from whose agent writes code best, to whose collaboration structure lets a group of people and a group of agents work together best. Cursor's answer is a shared task board, shared context, and agents that talk to each other — three pieces that fit together coherently as a design. But a coherent design is not the same as a smooth experience in use. Multiplayer has only just entered beta, and the real test is not on launch day but in the months that follow: how many teams actually use it for everyday development, how many on-call handoffs genuinely run smoother through it, and how many merge conflicts genuinely get stopped before anyone starts building. Those answers are not in the blog. They are in the usage record.

Views 15Comments 0

Comments (0)

ME
0/1000
Loading comments...

Sources

Browse projectsPublish your project

Related articles

A developer with glasses types on a laptop at a wooden desk, an external monitor to the left showing C code on a dark background, a small plant on the desk
News
Microsoft's Coding Model Stops Playing Second Fiddle: MAI Code 2 Scores 96% of Opus 5.5 for 5% of the Cost — Read the Three Caveats First

On 17 November 2026, Microsoft launched MAI Code 2 and Code 2 Flash: the larger model has 77 billion active parameters and a one-million-token context, averaging 63.2% across four benchmarks — close to GPT-6.1 Sol and Claude Opus 5.5 — at $0.309 per task. Read the three caveats first: promotional pricing, the lowest score of the three, and no long-horizon work.

Developer WorkflowProduct LaunchModel Updates
A developer types at a dual-monitor workstation; the left screen shows a dark code editor, the right a testing dashboard with green checkmarks and bar charts
News
Did Your Agent Get Better or Worse? AWS Open-Sources UAEF to Measure Agents from Every Framework with One Ruler

On 11 November 2026, AWS open-sourced UAEF: adapters turn traces from LangGraph, LangChain, Strands and Bedrock AgentCore into one format, then 36 metrics across 7 dimensions score them, flagging regressions past 5%. The judge model is hardened too — scores must cite verbatim evidence, and never decide safety.

Developer WorkflowProduct LaunchTesting & Quality
Against a black background, a conductor seen from behind raises a baton, with swirling trails of light circling beneath him like an orchestra being conducted
News
One API for 45 Models, and It Switches Providers When One Fails: Perplexity's Orchestrator Wants to Be the Switchboard

On 17 November 2026, Perplexity launched the Orchestrator API: one interface reaching OpenAI, Anthropic, Google, xAI and open-weight models such as GLM, Kimi and DeepSeek, billed at the answering model's published rate with no platform fee. When one provider fails, the same model retries on another deployment, and preview routing assigns requests to models by task.

Developer WorkflowProduct LaunchModel Updates