Cursor multiplayer Projects alternative: build together from any AI assistant

Cursor Projects is now multiplayer, inside Cursor. Here is how a whole team builds together from whichever AI app each person uses, Cursor included, with their own agents working on the same projects.

Nov 11, 202612 min read

On 10 November 2026, Cursor made Projects multiplayer. You invite teammates into a Project, everyone keeps their own chat with their own agents, and a shared task board shows who is doing what. Cursor names the problem well: "Multi-agent systems have so far served one person."

We agree, and it is the problem Server4Agent was built around. Working with AI stopped being a solo activity a while ago. The tool one person asked for gets used by five people, changed by three of them, and is expected to keep running after the chat that made it is closed.

Where we differ, as with Cursor's Build Live Apps last week, is the door you come in through. Cursor's multiplayer happens inside Cursor. Ours works from whichever AI app each person already uses: ChatGPT, Claude, Grok Bot, Muse, AgentX, Cursor itself, VS Code, Codex CLI, GitHub Copilot, Grok Build, and any other app that supports MCP. It also works for agents that live in no chat app at all, such as a script your engineer wrote or an agent framework running on a schedule. People and agents all work on the same projects, behind the same links, under one budget.

We make Server4Agent, so weigh our view with that in mind. Every Cursor detail below links to Cursor's own posts as they read on 11 November 2026. The feature is in beta and will change, so check them before you decide.

Quick answer

  • Use Cursor's multiplayer Projects when your team writes software together in Cursor and wants agents that plan around each other's work. It is built for a feature, a migration or a full app, run by coordinator agents, with a task board that links each task to its PR.
  • Use Server4Agent when the people building together use different AI apps, or when some of them are not engineers. Each person connects the app they already use, once, and every request from every app lands in the same projects at the same live links.
  • Agents count as teammates. An agent you run yourself connects with an API key, over MCP, the REST API or an SDK, and works on the same projects as the people.
  • They combine. Cursor is one of the apps you can connect, so an engineer can work from Cursor while the rest of the team works from something else.

What Cursor shipped

The facts, from Cursor's multiplayer announcement and the September post that introduced Projects:

  • A Project is a larger piece of work run by a coordinator agent. Cursor describes it as a way to "take on larger bodies of work, such as a feature, a migration, or a full app." You talk to the coordinator, and it directs worker agents that write the code. A Project runs on its own computer in the cloud, so closing your laptop does not stop it.
  • Multiplayer means teammates can join. In Cursor's words: "Invite your teammates into a Project, and you can plan, build and ship together, alongside all of your agents." Each teammate keeps their own one-to-one chat with their coordinator and workers.
  • Context is shared across everyone's agents. Requirements docs, diagrams, specs and mockups live in the Project, and "A decision made in one chat is accessible to every agent in the Project."
  • A shared task board shows who is doing what, what each person's agents are working on, and the PR behind each task.
  • Coordinators plan around each other. Cursor's examples include two pieces of work that touch the same page, and a database change where the agents agree on the order of work up front.
  • It is in beta. "It's rolling out in beta to all users in Cursor starting today." Neither post lists a price, a plan requirement or a limit on team size.

It is serious work. Agents that notice they are about to collide and settle the order between themselves solve a real problem, and that is the part of the launch we would most like to see become normal everywhere.

The question that decides it: who is on the team?

Cursor calls Projects "the first workspace where software teams work side by side with all of their agents." The key words are software teams. If that describes your team, and everyone is already in Cursor, their version fits and you can stop reading here.

Most of the multiplayer work we see is a different shape. A small company's internal tool usually involves:

  • an ops lead who asks for changes in ChatGPT,
  • a founder who uses Claude,
  • an engineer who reads the code in Cursor or VS Code,
  • an agent someone set up that runs every night and updates the data,
  • and a few people who never build anything and only open the link.

We wrote about how a team builds one tool when everyone uses a different AI assistant before either Cursor launch, and the reason it holds has not changed: people do not switch assistants because a tool asked them to. A multiplayer workspace that only one of those apps can enter leaves most of that list outside it.

How multiplayer works on Server4Agent

Server4Agent is where AI assistants and agents build, run and host things: web apps, dashboards, APIs, bots and scheduled jobs, each at a live link. Multiplayer comes from three pieces.

1. One account the whole team joins. The owner invites teammates by email from the Team page and gives each one a role. Servers, projects, secrets and the budget belong to the account, not to whoever happened to create them.

2. Each person connects the app they already use. The connection follows the person's login, not the app, so a request from any app reaches the same projects. The integrations page has the steps for each one:

  • Chat apps: Claude, ChatGPT, Grok Bot and Muse connect as a custom connector with a sign-in and no key to copy. AgentX connects as a tool in your workspace.
  • Editors: Cursor and VS Code read a short config block with an API key from the account.
  • Command line: Codex CLI, GitHub Copilot and Grok Build connect the same way.

3. Agents connect the same way people do. An agent built with LangChain, OpenClaw, Hermes or your own code uses an API key from the account. It can talk to the same MCP endpoint the chat apps use, or use the REST API and the SDKs for TypeScript, Python and Go. It sees the same servers and projects as the people do, and what it does is credited to the teammate whose key it uses.

That is the whole idea. There is no multiplayer mode to switch on. Every person and every agent talks to the same projects, so the project is where they meet.

An example: one tool, five people, one agent

Northstar Labs, a team of five, wants one page that tracks equipment out on loan to customers.

On Monday the ops lead, in ChatGPT, asks for it: a table of loans and due dates, with anything overdue flagged in red. ChatGPT creates the project, builds the page and replies with a link. The project starts private.

On Tuesday the founder, in Claude, opens the same project and asks to pull customer names from the company's CRM. The CRM key was saved on the account once, as a secret. The app uses it, and no assistant can read it back, so nobody pastes it into a chat.

On Wednesday the engineer, in Cursor, reads the code, tidies the import and sets the link to team-only.

Every night, a small agent the engineer wrote in Python pulls the day's returns from the warehouse system and writes them into the project through the SDK.

The two sales reps never build anything. They are viewers on the account. They open the link on Thursday and see who is overdue.

Nobody changed apps and nobody pasted code into a thread. There is one version of the tool, it is still running at the same address on Friday, and the activity feed shows who did what.

What everyone shares

SharedWhat it means for the team
Servers and projectsEvery connected app and agent sees the same ones. A project started in one app can be changed from any other
The live linkOne address per project, unchanged by every edit after it
Project filesThe code and data sit in the project's folder on the server, so the next assistant starts from what the last one left
SecretsSaved once on the account and attached to a project. Values are write-only, so no assistant or agent can read one back
VersionsEach task run on the project is saved with the request in plain words and the name of who asked. An owner or admin can go back to an earlier version in one step
ActivityOne feed for the account that credits each action to a person: who created a project, who started a task, who made it public, who added a key
BudgetOne cap for the whole account, covering compute and AI. No assistant or agent can raise it

Cursor gives its agents a purpose-built shared context system. Ours is simpler, and it works for any app: the project folder. Keep a short NOTES.md in the project with what the tool is for, the decisions made so far, and who looks after which part. Ask each assistant to read it before making a change and to add to it after. Every app on the team then works from the same page, literally.

Who can see and change what

Roles are set per person on the Team page:

RoleWhat they can do
OwnerEverything, including billing
AdminEverything a member can do, plus invite and remove people
MemberBuild and change projects, servers and secrets from any connected app
ViewerOpen only the app links shared with them. No building

Separately, each project has its own access setting. Every project starts private, and when you deploy it you choose who gets through:

AccessWho can open itDo they need an account?
TeamMembers of your account, or only the members you nameYes, they sign in to Server4Agent
PasswordAnyone with the link who enters the password you setNo
PublicAnyone with the linkNo

When someone leaves, remove them from the Team page. Their access ends on their next request, and that includes any API key they made for an agent: it stops reaching the team's projects rather than working until it expires.

Side by side

Cursor multiplayer ProjectsServer4Agent
Where people work fromCursorAny AI app that supports MCP, Cursor included
Built forSoftware teams building a feature, a migration or an appMixed teams, including people who never open an editor, plus agents you run yourself
How agents coordinateCoordinators plan around each other and agree the order of workThey do not negotiate. They share the project, its files and its history, and people decide who changes what
Shared contextDocs, diagrams, specs and mockups available to every agent in the ProjectThe project folder, which every connected app and agent can read
Tracking the workA shared task board with the PR behind each taskVersions credited to who asked, and an account-wide activity feed
What you end up withCode changes, tracked as PRsA running app, API, bot or scheduled job at a live link
People who only use the resultNot covered in Cursor's postsViewers open shared links, and a password link needs no account at all
PriceBeta, no price listedA free plan, paid plans from $29 a month, and one budget cap

Where Cursor's version is ahead

We would rather say this plainly than have you find it out later.

  • Agents that coordinate. Ours do not talk to each other. If two people ask their assistants to change the same page in the same minute, the changes can step on each other. On a shared tool, agree who is changing what, and use the activity feed and Versions to see who touched it last and to go back if you need to.
  • A context system built for the job. A notes file in the project works, but it relies on people asking their assistants to read it. Cursor's shared context does that without being asked.
  • A task board tied to PRs. For engineers who already run everything through pull requests, a board that links each task to its PR is the right shape.

If your team is engineers working on one codebase, all in Cursor, those three are worth more than anything on our list below.

When Server4Agent fits better

  • Your team uses more than one AI app. This is the main one. Each person keeps the app they like, and the work still lands in one place.
  • Some of the people building are not engineers. An ops lead in ChatGPT can join the same project as the engineer in Cursor without installing an editor. Our non-technical guide to shipping real tools from chat starts from zero.
  • Your agents are part of the team. An agent that runs every night, or one built on an agent framework, works on the same projects as the people, through the same account.
  • The result has to run somewhere. A bot that holds a connection, a job that runs every ten minutes, or a dashboard people open every morning all run on the same server, at a link.
  • People outside the account need to open it. Use a password link, and they need no account and no AI app.
  • You want one hard limit on spend. The account's budget cap covers compute and AI, whoever is asking. AI agent pricing and budget caps explains how to size it.

Set it up in four steps

  1. Connect your own app. Follow the steps for it on the integrations page.
  2. Invite the team. In the dashboard, open Team, enter each teammate's email and pick a role: member to build, viewer to only open links.
  3. Each teammate connects their own app and signs in with their own login, so the changes they ask for are credited to them.
  4. Start one project and share its name. Ask your assistant:

Create a project on Server4Agent called loan tracker, keep it team-only, and give me the link.

From then on, anyone on the team can ask their own app to change "the loan tracker project", and the link stays the same.

For an agent, create a key on the API keys page and give it to the agent. The SDK docs show the calls, and the MCP docs show how a framework agent connects to the same tools the chat apps use.

FAQ

Can my team build together if everyone uses a different AI assistant?

Yes. Each person connects the app they already use to the same Server4Agent account. Claude, ChatGPT, Grok Bot, Muse, AgentX, Cursor, VS Code, Codex CLI, GitHub Copilot, Grok Build and other MCP apps all reach the same servers and projects, and every change lands behind the same link.

Can I use Server4Agent from Cursor alongside Cursor Projects?

Yes. Cursor is one of the apps you can connect. Add the config block from the integrations page to your Cursor MCP config, and Cursor can create, change and deploy Server4Agent projects. Teammates in other apps work on the same projects.

Can an AI agent I built work on the same project as my team?

Yes. Give it an API key from the account. It can connect over MCP like the chat apps, or use the REST API and the TypeScript, Python and Go SDKs. Its actions are credited to the teammate whose key it uses, and the key stops working for the team if that teammate is removed.

Do people who only use the tool need an AI app or a seat?

They do not need any AI app. A viewer on your account opens the links shared with them. A password link opens for anyone with the password, with no account at all, and a public link opens for anyone.

What happens if two people change the same thing at once?

Their assistants do not coordinate with each other, so two changes to the same page in the same minute can collide. Agree who is changing what on a shared tool. Versions shows each task with who asked for it, and an owner or admin can restore any earlier version in one step.

How do I see who changed what?

Two places. The project's Versions list shows each task run on it, with the request in plain words and the name of who asked. The account's activity feed credits each action, such as creating a project, starting a task or making a link public, to the person who did it.

What does it cost?

There is a free plan for one person. Starter is $29 a month with 3 seats, Pro is $99 with 5 seats, and Business is $299 with 15 seats. Seats include the owner. The current numbers are on the pricing page, and whatever the plan, the budget cap you set is the most it can spend.

External references

Questions, or a tool you want built?

Ask us about this post, or tell us what you would hand to an assistant first. A person reads every message and answers within one business day.