Walkthrough: Cursor

Cursor is the most natural pairing with Q. The recommended setup is:

Use MCP for fresh, live project context
Optionally use Cursor Rules Export for stable context like fixed architecture files
Add a small IDE rule so Cursor always starts by calling getProjectContext()
Only add Cloud Agents if they are useful for your workflow

Integration Options

There are three ways to use Q with Cursor:

Integration	What It Does	Effort
MCP Server	Fresh, live access to your Q project from Cursor	5 minutes
Cursor Rules Export	Static rule files for stable context	10 minutes
Cloud Agents	Optional background implementation via Cursor	15 minutes

For most people working directly inside Cursor IDE, MCP + a tiny IDE rule is the best default setup.

1. MCP Server Setup

The MCP Server should be your primary integration because it always gives Cursor fresh data from Q. For the full MCP setup and format details, see the dedicated MCP Server page.

Create an MCP token in Q

In Q, open the relevant project or idea, go to the MCP section, and create a token for Cursor.

Open Cursor Settings

Go to Cursor Settings > MCP or use the generated "Add to Cursor" button directly from Q.

Add a new MCP server

If you are adding it manually, use the following structure:

{
  "mcpServers": {
    "Q-Product-Manager-for-your-project": {
      "url": "https://heyq.com/api/mcp/<idea-id>/mcp",
      "headers": {
        "Authorization": "Bearer <your-mcp-token>"
      }
    }
  }
}

Restart Cursor

After saving, restart Cursor. You should see Q's tools listed in the MCP panel.

Test the connection

Open a new Cursor Agent chat and ask: "Use the Q MCP to get the project context." The agent should call getProjectContext and return your project overview.

Use MCP for anything that should stay fresh: current project context, architecture, active missions, and latest decisions.

2. Cursor Rules Export

Cursor Rules are best for stable context that should live in the repo and does not need to be fetched dynamically every time.

A good example is a fixed architecture file or long-lived engineering guidance. In that case, you can export that content as Cursor rules and keep it out of the MCP token scope if you want the MCP token to stay more focused.

Export rules from Q

In Q, go to your project's integrations and select "Cursor Rules Export". Choose the files you want to export as rules.

Place in your repository

Copy the generated .mdc files into your repository's .cursor/rules/ directory.

Use rules for stable context

Export stable files like architecture, conventions, or other long-lived guidance into .cursor/rules/ so Cursor can load them locally without needing to fetch them through MCP.

Use Cursor Rules for stable context. Use MCP for fresh context. That combination usually works better than trying to push everything through one mechanism.

3. Add an IDE Rule

Add a small rule so Cursor automatically calls getProjectContext() at the start of a session.

Save this as .cursor/rules/q-mcp.mdc:

---
alwaysApply: true
---
 
This project uses Q (heyQ.com) as its product manager. If the Q MCP server (Q-Product-Manager-for-YOUR_PROJECT_NAME) is connected, call `getProjectContext` at session start to understand the project context, architecture, and current missions before making changes. If applicable, create or update dev tickets.

This gives Cursor a very small but high-leverage default behavior: always pull the latest truth from Q before starting work.

4. Cloud Agents Are Optional

If you actively use Cursor IDE, you often do not need Cloud Agents.

They can still be helpful in cases like:

you want to work on multiple projects simultaneously
you want to work across multiple worktrees within one project
you are away from your laptop and want to trigger work from heyq.com on your phone, then come back to a finished PR

If that sounds useful, set up Cloud Agents as an additional layer on top of MCP and Cursor Rules. For the full setup flow, prerequisites, and board activation steps, see the dedicated Cursor Cloud Agents page.

Cloud Agents are not the default recommendation for day-to-day Cursor IDE usage. Start with MCP and the IDE rule first, then add Cloud Agents only if they solve a real workflow problem for you.

If you use Cloud Agents, always review the resulting PR before merging.

Recommended Setup

For most teams, the best Cursor + Q workflow is:

MCP Server for live truth
IDE rule to always call getProjectContext()
Optional Cursor Rules Export for stable architecture or conventions
Optional Cloud Agents for background or parallel execution workflows

Mission Board Webhooks

On this page

Integration Options
1. MCP Server Setup
2. Cursor Rules Export
3. Add an IDE Rule
4. Cloud Agents Are Optional
Recommended Setup