Your shop runs on Slack pings and Asana boards. You upgraded to Cursor Ultra so agents can read the repo, draft fixes, and open pull requests while your engineers stay on client calls. Monday morning you have three agent branches, two half-finished chat threads, and a Slack message that says “can someone just merge the logging fix?”

Nobody answers with confidence—not because the team is careless, but because start was never defined. Cursor will happily keep working on whatever someone typed last. Asana only shows what humans remembered to ticket after the fact. The gap between “agent can act” and “this work is approved to consume billable time and touch production” is where small software consultancies (roughly 2–25 people) lose margin and trust.

The fix is not another chat rule or a longer AGENTS.md. It is a desk: a single queue where work lands as backlog, a human promotes to start (todo) before agents or engineers execute, and a human closes when it is done. That pattern works in Cockpit desks; the ideas below apply even if you are still stitching tools together.

Why Slack plus Asana breaks once agents join delivery

Before agents, the start line was informal but workable. A lead said “take it” in Slack; someone moved the Asana card to In Progress. PRs still went through review, and the founder could eyeball what shipped.

Agents change the physics. A Cursor session can run for forty minutes, touch six files, and open a PR while the person who asked is in a standup. The agent does not know:

• Whether that request was a throwaway idea or committed scope
• Whether another client’s repo is off limits today
• Whether this fix should wait until after a release freeze

So teams default to chaos: agents work on whatever was mentioned most recently; humans merge when pressured; Asana gets updated when someone needs a status report. You pay for Ultra seats and still re-litigate “who said go?” in every retro.

The implement-for-others version looks the same. An MSP routes L2 tickets into a shared channel; a product studio keeps a “quick fixes” Slack room for the founder. Without promote-to-start, the fastest agent wins—not the highest-priority customer.

Put every unit of work on a desk first

Treat a desk as the contract between “idea” and “execution.” One desk might be Client delivery, another Internal tooling, another MSP L2 queue. Every piece of work—human or agent—gets a row before anyone opens Cursor.

Backlog means captured and visible, not authorized. Examples:

• “Add retry logic to the webhook handler (Acme SaaS)”
• “Update pricing copy on marketing site—wait for legal”
• “Investigate 500s on staging—no code until repro steps attached”

Nothing in backlog should trigger an agent run that writes to the repo or opens a PR. Chat can still brainstorm; the desk row is where the org admits “this exists.”

That alone cuts duplicate agent work. Two engineers asking Cursor for the same logging change in different threads usually means two branches. One backlog row, one owner, one promote decision.

Promote-to-start: the human todo gate

Promote-to-start is the deliberate flip from backlog to todo. One accountable human—often the delivery lead, tech lead, or on-call principal—moves the row when all of these are true enough for your risk tolerance:

1. Scope is bounded — files, environment, and client are named (not “fix the app”).
2. Priority is real — this beats other todo work for the next few hours.
3. Agent or engineer is named — including which Cursor workspace/repo and which PAT or machine identity may run.

Only after promote-to-start should someone tell Cursor Agent Mode to implement, or should a cron/desk pickup run against that task. The todo state is the org’s “go”—not the last Slack reaction.

For a 12-person consultancy, the ritual can be lightweight: twice a day, the delivery lead promotes three todos from backlog and explicitly does not promote the rest. Slack threads that never became rows stay chat, not stealth work.

What Cursor Ultra does after promote

Once promoted, Cursor fits the same lane you already bought:

• Agent reads the linked task context (title, acceptance notes, repo path in the row).
• Work happens in a branch; PR links back to the desk row.
• Humans review the PR; merge is separate from “start” unless you add a merge gate later.

The point is sequencing: desk → promote → Cursor → PR → human close. Without promote, Ultra is an expensive autocomplete on whatever was loudest in Slack.

Close on the desk, not only in Asana

When the PR merges—or when you decide not to ship—close the desk row. Closed rows are your decision exhaust: what started, what finished, what got killed before an agent burned an hour.

Asana can remain your client-facing timeline if clients require it. The desk is the system of record for authorization to work, especially agent work. Sync summaries to Asana if you must; do not let Asana be the only place “allowed to start” was recorded, because agents never read Asana unless you build that bridge—and even then, promote-to-start should stay human.

Closing also trains the team. Rows that sit in todo for a week without a PR signal a scoping or priority problem before the next Ultra invoice.

A minimal rollout for a 2–25 person software shop

You do not need a full platform swap on day one. A workable week-one version:

1. Name 1–2 desks — e.g. “Billable client repos” and “Internal / R&D.”
2. Rule: no agent PRs without a todo row — enforce in standup, not with more tooling at first.
3. Backlog hygiene — anything mentioned in Slack for more than ten minutes gets a backlog row or is explicitly dropped.
4. Promote in a fixed cadence — morning and after lunch; same person when possible.
5. Link PRs to rows — title or description includes the desk id so review is traceable.

Week two, wire Cursor sessions to start from the todo description (paste or MCP pull from Cockpit if you use it). Week three, measure: fewer orphan PRs, fewer “wait, we weren’t doing that yet” reverts.

If you implement the same pattern for clients—MSP ticket desk, product eng backlog—the sell is operational: their agents and contractors get the same start line, not a black box that ships while the account manager is offline.

Where this leaves Cursor in your stack

Cursor Ultra stays the execution engine. Slack stays the ambient conversation. Asana can stay the client report. The missing piece is the authorization layer: backlog → promote-to-start → todo → work → close.

Cockpit desks are built for that layer—tasks, agent runs, and human gates in one place—so you are not rebuilding promote-to-start in Notion formulas or Asana custom fields. Whether you adopt Cockpit or a spreadsheet desk this quarter, the behavior is the same: nothing agentic starts until a human promotes it.

If your team already has Ultra seats and the PR queue feels faster than your nerve, start with one desk and one promote ritual tomorrow. The cost of an unpromoted agent hour is usually higher than the cost of saying “not yet” out loud.

Book a discovery call at cloudbeast.io/schedule if you want help mapping desks to your repos, clients, and Cursor setup without bolting another chat bot onto Slack.