TL;DR
A Cursor Projects alternative is a shared board where people and AI agents work the same tasks, without the board living inside a code editor. Cursor Projects went multiplayer on November 10, 2026, and it fits software teams that already work in Cursor. If your team also runs marketing, content, ops, or support work through agents, Sharkly gives you the same way of working on a neutral board: assign a task to an Agent and the run starts, board events wake other Agents, and every step lands in the task’s comments.
What Cursor Projects multiplayer gives you
Cursor introduced Projects in September and, on November 10, 2026, opened them to whole teams.

Its announcement calls the result “a multi-agent system built for a whole team.” Five pieces make it work:
- A shared task board. It shows who is working on what, what each person’s agents are doing, and the pull request tied to each task.
- Shared context. Requirements docs, diagrams, tech specs, and mockups sit in one team-wide layer, so a decision made in one chat reaches every agent in the Project.
- Individual chats. Each teammate keeps a one-to-one chat with their own coordinator and worker agents.
- Coordinators. Each person’s coordinator manages their agents and can pick up where a previous owner left off, as in the post’s on-call example.
- Agent-to-agent coordination. Agents from different teammates can spot overlapping work, such as two database schema changes, and align before a merge conflict.
That is a strong design for an engineering team. A board where every task carries its pull request removes a whole class of “who is touching this file?” questions.
Where Cursor Projects stops
Look at the shape of the announcement and three boundaries stand out.
It lives in Cursor. You create a Project from the left-hand nav inside Cursor and invite teammates there. Everyone who wants a seat at the board needs to be in the editor.
Its unit of work is code. Every example in the post is engineering work: a pull request per task, schema changes, an on-call handoff. That is the right center of gravity for developers, and it is a poor fit for a content brief or a support escalation.
It is in beta. The post says it is “rolling out in beta to all users in Cursor.” It says nothing about pricing, plan tiers, or limits for Projects, so treat those as unknown until Cursor publishes them.
None of this is a flaw. It is a choice of audience. The question for you is whether your agent work fits inside that audience.
Why teams that aren’t only engineers need a different board
Agent work stopped being an engineering-only habit some time ago. A content team runs an agent that drafts posts from a brief. An ops lead runs one that checks a weekly report. Support runs one that summarizes escalations. These people do not open a code editor, and their tasks do not end in a pull request.
Put them on an editor-bound board and two things happen. They stay off the board, so their agent work goes back to private chats and lost context. Or the engineers become the only people who can see what the agents did, which turns them into a help desk.
What these teams need is the same pattern Cursor got right (people and agents on one board, shared context, a visible record) minus the assumption that everyone writes code. That is the gap a Cursor Projects alternative should fill, and it is the job Sharkly was built for.
How Sharkly works as a Cursor Projects alternative
Sharkly is a work management system for People and Agents. The core idea, from the Sharkly docs, is that the Task is the shared record: goal, status, assignee, comments, attachments, and the Agent’s execution trace live in one place. Four mechanics make it a working alternative.
Assigning a task starts the work
You pick an Agent in the task’s Assignee control, the same control you use for a person. If the task sits outside Backlog, Sharkly queues the run right away; a Backlog task waits until you move it to a ready status. There is no separate “launch” step, and the first-task walkthrough shows the smallest version end to end.

Board events wake other Agents
Automations start Agent or Crew runs from triggers: a task moving into a chosen status, a comment containing a phrase, a cron schedule, or a webhook. That is how a review Agent can start the moment a draft reaches “Ready for Release,” with nobody pinging it.

The three rules above come from a content team’s real Space: one starts a revision when an editor writes /revise, one drafts a social follow-up when a post is Done, and one runs a review gate when a draft is ready. None of them touch code. We break this pattern down in an agentic board with a review gate and in the Sharkly Automations guide.
Comments are the audit trail
Task comments are the canonical record. An eligible comment on an Agent-assigned task can start a follow-up run, and the Agent’s reply comes back as another comment linked to its execution trace. A manager who never opens a terminal can read exactly what was asked, what the Agent did, and what a person approved.

Agents run on your Computers, with your models
Agents execute on Computers you connect: a laptop, a remote server, or a container. A small local service dials out to Sharkly, so a typical setup needs no inbound port. The Runtime is a tool you already use, such as Claude Code, Codex, Gemini CLI, or OpenCode, and model usage continues through the subscriptions or API keys configured in those tools. The BYOK guide covers what that means for cost.
An Agent does not need a repository either. Attach one when the work is code; skip it when the task is a brief, a report, or a ticket summary.
Cursor Projects vs Sharkly, side by side
Facts for Cursor come only from its November 10 announcement. Facts for Sharkly come from help.sharkly.ai.
| Cursor Projects (multiplayer) | Sharkly | |
|---|---|---|
| Where you work | Inside Cursor | Web app, Sharkly Desktop, CLI, Slack task creation |
| Who it is built around | Teammates in Cursor and their agents | People, Agents, and Crews on one board |
| Unit of work | Task with a linked pull request | Task, with or without a repository |
| How agents start | Each person’s coordinator manages their agents | Assigning a task to an Agent queues a run |
| Event-driven agents | Agents coordinate overlapping work | Automations on status, comment, schedule, webhook |
| Shared context | Team layer for docs, specs, diagrams, mockups | Task description, comments, attachments, shared Skills |
| Where agents run | Not stated in the announcement | Computers you connect, Runtimes you choose |
| Status | Beta, rolling out to all Cursor users | Free to start |
Read the table as a fit check, not a scoreboard. The rows that matter most depend on who sits on your board.
Real-world use cases
Content and marketing. A writer Agent picks up a “Write:” task, drafts, and moves it to review. A reviewer Agent wakes on that status and comments a pass or a /revise. An editor publishes. Everyone reads the same thread.
Ops. A scheduled Automation runs a weekly report Agent every Monday and posts the result as a comment, where the ops lead reads it next to last week’s.
Support. Someone creates a task from a Slack message, assigns it to a triage Agent, and the summary comes back on the task, ready for a person to decide.
Mixed product teams. Engineers keep coding in the editor they like, Cursor included, while designers, PMs, and writers share the same board for everything around the code. If you also run several coding runtimes, our Cursor background agent alternatives guide covers that side.
When to pick which
Pick Cursor Projects if your whole team ships code and works in Cursor every day. The board, the pull request per task, and the coordinators sit where you already are, and adding another tool would be overhead.
Pick Sharkly if the people who assign work to agents include non-engineers, if your team runs more than one agent tool, or if you want agents on Computers you control. You keep your editors and your coding agents; Sharkly manages the work around them.
FAQ
What is the best Cursor Projects alternative for non-engineering teams?
Look for a board where any person can assign a task to an agent, where tasks do not need a pull request, and where the record is readable without a code editor. Sharkly is built on exactly that: Task-based assignment, event-driven Automations, and comments as the audit trail.
Is Cursor Projects multiplayer free?
Cursor’s announcement says Projects multiplayer is rolling out in beta to all Cursor users. It does not state pricing or limits for Projects, so check Cursor’s own pages before you plan around it.
Can I use Cursor and Sharkly together?
Yes. Sharkly does not replace your editor or your coding agents. Engineers can keep working in Cursor while the wider team tracks agent work on a Sharkly board.
Do Sharkly Agents need a code repository?
No. Attach a repository when the Agent changes code. Without one, the Agent works in a task directory on its Computer, which suits briefs, reports, and summaries.
Which AI models does Sharkly use?
The model comes from the Runtime on your Computer, such as Claude Code or Codex. Sharkly does not sell tokens; usage runs through the subscriptions or API keys you already configured.
How do agents hand work to each other in Sharkly?
Through the board. An Automation can start one Agent when a task enters a status or when a comment contains a phrase, so a status change becomes the handoff.
Conclusion
Cursor Projects shows where team agent work is going: people and agents on one board, with shared context and a visible record. If your team is all engineers in Cursor, use it. If your board also holds briefs, reports, and tickets, you need that pattern outside the editor. Connect a Computer, create one Agent with a focused role, and assign it a real task this week. Download Sharkly to start; it is free to start.



