Cursor 3.11: Side Chats and Searchable Agent Transcripts

Cursor 3.11, released July 10, 2026, is easy to misread as a UI refresh: a way to open a second chat, a search box for old conversations, tidier pickers. The more useful reading is ergonomic. Since April, Cursor has been pushing developers toward running many agents at once — and 3.11 is the release that finally addresses what that workflow breaks: your ability to ask a side question without derailing a run, and to find what any past agent actually did.

The stakes are practical, not philosophical. Once agents run in parallel — locally, in worktrees, in the cloud — the scarce resource stops being model capability and becomes developer attention. Every time you interrupt a running agent to ask a clarifying question, you pay a context tax. Every time you scroll through an old transcript hunting for the moment an agent made a decision, you pay a retrieval tax. 3.11 attacks both taxes directly.

This guide covers what actually shipped, how side chats and transcript search change day-to-day parallel-agent work, a full local-versus-cloud matrix of Cursor’s hook events (which Cursor’s own docs only present as prose lists), the picker redesign, and the honest economics of running agents in parallel. Feature-level claims trace to Cursor’s own changelog and documentation — independent coverage of 3.11 specifically is still thin, as you would expect for a release that is days old.

Per the official changelog, Cursor 3.11 ships four things: side chats (durable secondary conversations that branch off a running agent), agent transcript search (a local index over past conversations), redesigned project and repo pickers, and five new hook events for cloud agents. It landed July 10 — the third release in eleven days, after 3.9 on June 29 (the Cursor mobile app for iOS, with cloud-agent remote control) and 3.10 on June 30 (Team MCPs and organization groups in team marketplaces). That cadence follows June’s design-mode and voice release and continues a shipping rhythm Cursor has held all year.

Worth separating out: the same week, xAI announced that Grok 4.5 became the default model in Cursor on all plans starting July 8, 2026 — a vendor-stated claim from xAI’s own announcement, and not part of the 3.11 changelog. If you saw the two stories blended together, that is coverage compression, not what Cursor announced. We covered the model side separately in our look at Grok 4.5 and the Cursor data flywheel.

The problem side chats solve is one every heavy agent user knows. An agent is forty minutes into a refactor, and you want to ask something adjacent — why it chose that pattern, whether an alternative approach would work, what a term in its output means. Your options used to be bad: interrupt the run and contaminate its context, open a disconnected new chat that knows nothing about the work in progress, or hold the thought and lose it.

Side chats give that question a home. Type /side or /btw, or hit the plus button at the top of the chat panel, and a secondary conversation opens that branches off the running thread. Cursor’s product copy frames the intent directly: “Open a side chat to ask questions, explore ideas, and investigate tangents.” Crucially, each side chat is a durable, full agent conversation — you can follow up in it, come back to it later, and @-mention it to pull its context back into the main thread when a tangent turns out to matter. /btw is the shorthand for a side question that does not stop the current run.

By default, side chats are scoped to reading, searching, and answering — clarification questions, exploring alternatives without committing to a pivot, sanity-checking a decision while the main agent keeps working. That scoping is a design choice worth noticing: it makes the side chat safe by default, in the same spirit as Cursor’s earlier move to have agents ask clarifying questions before executing plans. The escape hatch for uncertainty is now structural, not improvised.

When should a question become a side chat versus something else? Our working decision rule after a weekend with the release:

The second half of the release fixes retrieval. Agent transcripts pile up fast when a team runs agents in parallel, and until now finding anything in them meant remembering which conversation held it. Cursor’s own framing of the problem is telling: search results now go beyond matching conversation names and PR numbers — the index searches actual message content.

Mechanically, there are two layers. Across conversations, a new local search index is exposed in the Agents Window via the command palette (Cmd+K); Cursor says the index “scales search to thousands of conversations” with fast performance — a vendor performance claim we have not benchmarked, but the architectural choice of a local index is the part that matters for teams with code-privacy constraints. Within a single open conversation, Cmd+F now searches transcript text with a match counter and next/previous navigation — mundane until you have scrolled a four-hour agent run looking for the one moment it explained a migration decision.

The second-order effect is the interesting one. Once transcripts are searchable, they stop being exhaust and start being a record: why an agent chose an approach, what it tried and abandoned, what it said before a human redirected it. Teams that treat agent runs as auditable work products — the way they already treat PR discussions — just got their query layer.

The quietest change in 3.11 is the one platform teams will care about most: five new hook events for cloud agents — beforeSubmitPrompt, afterAgentResponse, afterAgentThought, stop, and subagentStart — aimed at letting teams observe agent reasoning and output on cloud VMs and build self-correcting loops around them. Hooks are the guardrail layer of Cursor’s agent platform: shell scripts (or LLM-evaluated policies) that fire at defined moments in an agent’s lifecycle and can log, modify, or block what happens next.

Cursor’s docs describe two execution modes. Command-based hooks — the default — receive JSON on stdin and reply on stdout; exit code 0 means success, exit code 2 blocks the action, and other codes fail open. Prompt-based hooks let an LLM evaluate a natural-language policy and return an ok/reason verdict — but they are local-only, not available to cloud agents. Configuration loads from four sources in priority order — Enterprise, Team, Project, then User — and the user-level ~/.cursor/hooks.json is also not available to cloud agents, which matters if your guardrails currently live in personal config.

Cursor’s own documentation presents cloud support as two prose lists split across the page. The matrix below consolidates all 20 documented hook events into one view — by our count from those lists, 14 run on cloud agents and 6 remain local-only.

Three gaps deserve attention before you architect around this table. First, MCP hooks (beforeMCPExecution, afterMCPExecution) do not fire in cloud agents — Cursor’s docs describe them as deferred for read-only environments, so if your policy layer screens MCP calls, it only protects local sessions today. Second, the session-lifecycle pair (sessionStart/sessionEnd) and workspaceOpen are tied to the IDE’s lifetime and simply have no cloud equivalent. Third, the Tab hooks are editor-bound by nature.

The least glamorous part of 3.11 is a genuine tell about where Cursor thinks its users are. The project and repo pickers were rebuilt around location: search is now scoped by This Computer, Cloud, or Remote Machine rather than one undifferentiated global list. That only makes sense as a design priority if a meaningful share of users now hold projects across all three.

• In-flow repo connection. You can create a project and connect a GitHub, GitLab, or Azure DevOps repo directly inside the picker, without leaving the flow.
• Faster branch access. The branch picker surfaces the default branch plus recently-used branches first; projects can be removed from Recents in one click.
• Escape hatches and consolidation. Typing “none” or “no repo” jumps straight to a no-repo session; a consolidated Remote Machines menu replaces the older scattered options; multi-repo selection becomes a toggle, replacing the old Set Up Workspace builder; cloud repos get a folder icon with a cloud badge.

None of this is a headline. All of it reduces the per-agent setup friction that compounds when you launch several agents a day across machines — which is precisely the workflow the rest of the release assumes.

Read in isolation, 3.11 is a quality-of-life release. Read in sequence, it is the fifth consecutive move in one direction. Cursor 3.0 (April 2, 2026) introduced the Agents Window — the agent-first interface for running many agents in parallel across repos and environments: locally, in worktrees, in the cloud, and over SSH. Then came Automations — always-on agents that do not wait for a human to initiate — the iOS app in 3.9 for starting, monitoring, and guiding cloud agents from a phone, Team MCPs and organization groups in 3.10, and now side chats plus transcript search in 3.11.

Every step serves the same user: someone supervising agents they did not personally start. The adoption backdrop explains the urgency. By April 2026, per InfoQ’s reporting on the Cursor 3 launch, agent usage inside Cursor had inverted relative to Tab — roughly twice as many users running autonomous agents as using tab-completion — and 35% of merged pull requests inside Cursor’s own engineering org were written by autonomous cloud agents. Both figures are April-2026 snapshots that have not, to our knowledge, been re-verified since; treat them as historical context for why Cursor is building this way, not as current-state stats for the 3.11 release. Cursor co-founder Michael Truell described the destination as “the third era of software development, where fleets of agents work autonomously to ship changes.”

That quote, from months before this release, is the cleanest explanation of why 3.11 looks the way it does. If humans are not always initiating, the human-facing surface has to be built for checking in rather than kicking off: a side chat is how you check in on a run without disturbing it, and transcript search is how you check in on work that finished while you were elsewhere. Our interpretation of the trend: the IDE agent race has shifted from a capability contest (whose model writes better code) to a supervision contest (whose interface lets one developer safely oversee the most concurrent work). For how that contest played out across vendors in the first half of the year, see our H1 2026 AI-coding retrospective.

The ergonomics only matter if the underlying workflow pays off, so it is worth being honest about the math. The most concrete practitioner account we have found — a DEV Community write-up by GDS K S from May 2026 — ran three parallel refactor agents (logging, error handling, tests) and reported that roughly three sequential afternoons of work compressed to about one day of elapsed time, using Git worktrees to keep each agent’s working directory isolated so there were no file-level write conflicts.

The same account flags the failure mode 3.11’s ergonomics cannot fix: without explicit scope constraints — “do not touch test files” and the like, which the author describes as load-bearing, not optional — parallel agents drift into each other’s shared files. Side chats reduce the cost of supervising parallel work; they do not reduce the token bill or substitute for seam design.

Looking forward, our projection is that this class of tooling — branchable conversations, searchable agent history, hookable lifecycles — becomes table stakes across agentic IDEs within a few quarters, the way multi-cursor editing and integrated terminals once did. The durable differentiator will be governance: which platform lets a team prove, after the fact, what its agents did and why. Transcript search plus afterAgentResponse and afterAgentThought hooks are the early skeleton of exactly that audit layer. If your team is working out how to adopt parallel-agent development — seam design, guardrails, review workflow — that operating model is what our AI transformation engagements are built around.