Cursor 3.11 Lets Developers Run Parallel AI Chats Without Stopping Their Agent

Cursor just shipped version 3.11, and the headline feature is deceptively simple: you can now open a side chat while your main agent is still running. But zoom out and this update is really about one thing -- making it less painful to manage the growing complexity of long-running, multi-agent workflows.

The problem with one conversation at a time

As Cursor has evolved into a full agent platform, a tension has emerged. The working life of a software engineer has become increasingly complex -- a single engineer might oversee dozens of coding agents at once, launching and guiding different processes as necessary. It's a lot to keep track of, and human engineers' attention has quickly become the limiting resource. The old single-thread chat model just doesn't fit that reality.

Before this release, asking a clarifying question mid-task meant either interrupting the agent or holding the thought in your head until it finished. Neither is great when you're deep in a refactor.

Side chats: parallel thinking without the context switch

You can open a side chat to ask questions, explore ideas, and investigate tangents without interrupting your main agent conversation. Use /side, /btw, or the plus button at the top of the chat panel to create a new side chat that has context from the main chat.

Each side chat is a durable, full agent conversation that you can follow up on, revisit later, and at-mention to pull context back into the main thread. That last part matters -- it's not a throwaway scratchpad. You can @mention a past side chat to inject its conclusions directly into your main conversation.

By default, side chats focus on reading, searching, and answering. Use them to ask clarification questions, research alternatives without committing to a pivot, and sanity-check a decision while the main agent continues running.

Practical scenarios where this shines:

• Your agent is mid-refactor and you want to quickly check if a library supports a specific API -- open a side chat, ask, get your answer, keep going
• You're unsure whether to use approach A or B -- spin up a side chat to explore both, then @mention the conclusion in your main thread
• You want to sanity-check the agent's reasoning without stopping it -- side chat lets you interrogate without interrupting

Transcript search: your conversation history is now a knowledge base

Heavy Cursor users accumulate hundreds, sometimes thousands of agent conversations. Until now, finding anything in that history meant remembering the name or PR number. In the Agents Window, you can now search agent transcripts from the command palette (Cmd+K). Cursor builds a local search index that scales search to thousands of conversations with snappy performance.

This is a direct response to user demand. A community forum thread had requested the ability to hit Ctrl+F when an agent chat transcript window is focused to search the chat -- and Cursor delivered that too. You can also search within an existing conversation using Cmd+F, jump between matches, see a match counter, and keep searching as you scroll through long transcripts.

The index is local, which means it's fast and private. No round-trips to a server to search your own chat history.

New cloud agent hooks: programmable control over the agent loop

This is the update that will matter most to teams building on top of Cursor's cloud agents. Hooks are lifecycle callbacks -- scripts that fire at specific moments in the agent's execution, letting you observe, validate, or redirect behavior. Cursor has added new hooks that let you observe and control the agent conversation itself: prompts, responses, thinking, subagents, compaction, and turn completion.

The new hooks now available for cloud agents include:

• beforeSubmitPrompt -- intercept and validate a prompt before it's sent
• afterAgentResponse -- inspect the model's reply after each turn
• afterAgentThought -- observe the agent's internal reasoning (chain-of-thought)
• stop -- trigger logic when the agent finishes
• subagentStart -- hook into when a sub-task agent spins up
• preCompact -- observe context window compression events

Cloud agents run command-based hooks from your repository. If you have hooks defined in .cursor/hooks.json at the root of your project, cloud agents pick them up and run them during their work. This is a big deal for teams that want to build self-correcting pipelines -- for example, a stop hook that automatically re-queues the agent if tests fail, or an afterAgentResponse hook that logs every model output to an observability platform.

Here's a minimal hooks.json that logs agent responses and blocks dangerous shell commands:

// .cursor/hooks.json
{
  "version": 1,
  "hooks": {
    "afterAgentResponse": [
      { "command": "./scripts/log-response.sh" }
    ],
    "beforeShellExecution": [
      {
        "command": "./scripts/validate-shell.sh",
        "matcher": "rm|curl|wget"
      }
    ],
    "stop": [
      { "command": "./scripts/run-tests-and-requeue.sh" }
    ]
  }
}

Previously, project-level hooks like afterAgentResponse and stop that executed locally in the Cursor IDE did not work in the cloud agent VM environment. That gap is now closed.

Redesigned project and repo pickers

Cursor has simplified the project and repo pickers and made them more powerful. You can now stay in the picker for workflows that used to send you elsewhere -- for example, you can create a project and connect GitHub, GitLab, or Azure DevOps without leaving the picker.

A few notable picker improvements:

• Search is now scoped to where you're working -- This Computer, Cloud, or a specific remote machine -- instead of one global search box.
• Multi-repo and multi-root selection is now a toggle inside the Cloud and This Computer flyouts, replacing the old separate workspace builder
• The branch picker opens on your default and recently used branches, with full search for everything else
• If a repo exists only in the cloud, the picker now suggests cloning it locally

Availability and pricing

The update is labeled version 3.11 in the Cursor changelog. All features in this release -- side chats, transcript search, and the redesigned pickers -- are available now. On Enterprise plans, cloud agents also run team hooks and enterprise-managed hooks configured through the web dashboard. The new cloud agent hooks are available across paid plans, with the full hooks support matrix documented in the official hooks docs.

The broader picture here is Cursor continuing to push toward a model where the agent is the primary unit of work, and the IDE is the control plane around it. Side chats, searchable history, and programmable hooks are all infrastructure for that future -- making it easier to supervise, interrogate, and extend agents without getting in their way. You can see the full 3.11 changelog on Cursor's website.