Bob with Cursor: dispatch bug-fixing agents from Slack

Matthew, founder of Bob · Published July 30, 2026

Short answer

Connect Bob to Cursor and a bug report can become a running Cursor Cloud Agent without the team leaving Slack. Bob can collect the reproduction steps and logs from the conversation, pull in the linked Linear or Jira issue, launch an agent against the right GitHub repository and base ref, and ask Cursor to open a pull request when the fix is ready.

Bob can then list agents, check one agent's status, read its conversation, and send a follow-up instruction if the first attempt needs direction. Cursor work still happens in Cursor's remote environment. Bob coordinates it from the Slack thread and records the connected-app actions in his receipt.

What Bob can do with Cursor agents

Cursor describes Cloud Agents as autonomous coding agents that work against connected repositories in remote environments. Cursor specifically names fixing bugs as a primary workflow. Bob's Cursor catalog connection exposes actions to launch an agent, list agents, get an agent's status, read its conversation, and add a follow-up instruction. The launch action accepts a prompt, source repository, source ref, optional model and target branch, and an option to create a pull request.

That gives Bob a complete coordination loop from Slack:

• Gather the bug, expected behavior, evidence, repository, and base branch.
• Launch a Cursor agent with a focused implementation and test prompt.
• Check whether the agent is running, blocked, failed, or complete.
• Read what the agent tried and send a follow-up with missing context.
• Return the branch or pull request to the original Slack thread for review.

Cursor's own Cloud Agents guide describes handing off bugs from Slack and running multiple agents for harder fixes. The Cursor Launch Agent action used by Bob's connection layer documents the repository, ref, model, branch, and pull-request inputs.

Five useful Bob and Cursor workflows

1. Hand a reported bug to a Cursor agent

"Bob, use the repro steps and stack trace in this thread to launch a Cursor agent against acme/web on main. Fix the checkout total bug, add a regression test, and open a pull request. Do not change the payment-provider integration."

Bob turns the thread into a focused agent prompt, selects the repository and base ref, and shows the launch for approval. After approval, Cursor works in its remote environment and can create the review branch or pull request requested in the action.

2. Launch competing attempts for a hard bug

"Launch two Cursor agents on this race condition with different prompts. Have both add a deterministic test and open separate pull requests so we can compare the fixes."

Parallel attempts can be useful when the failure is subtle, but they also consume more Cursor usage. Bob makes each launch explicit rather than multiplying agents silently.

3. Redirect an agent without starting over

"Check the Cursor agent for ENG-482. Read its conversation. If it changed the public API, tell it to preserve the existing contract and solve the bug behind the adapter."

Bob can inspect the agent's status and conversation before sending a follow-up. The follow-up is another external write, so it stays behind approval by default.

4. Turn an issue queue into reviewed agent work

"Find the three Linear bugs tagged agent-ready. For each one, gather its acceptance criteria and linked GitHub context, then prepare a Cursor agent launch. Ask me before launching any of them."

Bob handles the cross-app preparation. The issue tracker supplies the problem, GitHub supplies repository context, and Cursor supplies the remote coding agent.

5. Report the result where the bug started

"Check the agent for the checkout bug. If it is complete, summarize the files changed, tests run, remaining risks, and pull request in this thread."

Bob can read the agent conversation and combine it with the GitHub pull request. The reviewer gets the outcome and evidence in the original Slack thread, not a vague "the agent finished."

Cursor analytics still matter

The same Cursor connection can also support management and engineering-operations work. Cursor's Admin API exposes team members, daily usage, spending, detailed usage events, and repository blocklists. Its AI Code Tracking API adds commit-level AI usage and accepted changes.

Ask Bob for a weekly adoption brief, a spend threshold report, or AI code tracking joined with GitHub delivery. Treat those numbers as operating signals, not employee rankings. Usage volume does not prove engineering quality.

How the connection works

Create a Cursor API key from the Cursor dashboard's integrations area. Cursor Cloud Agents also need access to the GitHub repositories they will work in. In Slack, ask Bob to connect Cursor. Bob posts a Connect Cursor button, and the hosted connection page collects the key outside Slack. Bob does not ask you to paste the secret into a channel.

1. In Slack, tell Bob: "Connect Cursor."
2. Open the Connect Cursor button Bob posts.
3. Enter the Cursor API key in the hosted connection flow.
4. Return to Slack and ask Bob to retry the original request.

In Bob today, Cursor is a workspace-scoped catalog connection. Treat the key as a team automation credential: use least privilege, connect only the repositories Cursor should change, and make the acting account clear to the team.

What Bob does not claim

A useful connection page should say what the connection cannot do.

• No editor remote control. Bob launches a separate Cloud Agent. He cannot see an open Cursor tab or steer an active local coding session.
• No automatic merge. An agent can prepare a branch or pull request, but normal GitHub reviews, checks, and branch protections still decide what lands.
• No automatic productivity score. Lines changed, requests made, or suggestions accepted are not a reliable employee ranking.
• No secret in Slack. The API key belongs in the hosted connection flow, not a message.
• No silent agent launches by default. Listing agents and reading status can move automatically. Launches and follow-ups ask unless your team deliberately changes that policy.

Bob can also write code with his own sandbox and GitHub connection. That is a different execution path. With the Cursor connection, Bob delegates the coding task to Cursor's remote agent and coordinates the result from Slack.

FAQ

What can Bob do with Cursor?

Bob can launch Cursor Cloud Agents, list agents, check status, read agent conversations, send follow-up instructions, and use Cursor's administrative analytics for engineering reports.

Can Bob use a Cursor agent to fix a bug?

Yes. Give Bob the bug context, repository, and base ref. Bob can launch a Cursor Cloud Agent with that prompt and optionally ask it to open a pull request. Launching the agent is an external write, so Bob asks for approval by default.

How does Bob authenticate to Cursor?

Create an API key in the Cursor dashboard and enter it in Bob's hosted connection flow. The key is collected outside Slack and stored by the connection provider.

Does Bob take over my open Cursor editor?

No. Bob launches a separate Cursor Cloud Agent against a connected GitHub repository. He does not see or steer a developer's open local editor session.

Is the Bob and Cursor connection read-only?

No. Listing agents, checking status, reading conversations, and reporting analytics are reads. Launching an agent, sending a follow-up, or changing settings is a write and asks for approval by default.

Start with one bounded bug

Choose a reproducible bug in a repository already connected to Cursor. Give Bob the expected behavior, evidence, repository, base ref, constraints, and the test that should prove the fix. Ask Cursor to open a pull request rather than merge anything.

Then connect GitHub, Linear, or Jira so Bob can gather the issue context and return the reviewable result where the work started.