Cursor 3.11 Side Chats for Game Developers - What Changed in 2026

Cursor 3.11 side chats solve a pain every Unity and Godot lead already knows: you are deep in an agent refactor, a clarifying question appears ("does this repo even use Addressables here?"), and asking it in the main thread derails the plan you spent twenty minutes building.

On July 10, 2026, Cursor shipped version 3.11 with durable Side Chats, local conversation search across agent transcripts, redesigned project and repo pickers, and new cloud-agent hooks. That is not a cosmetic chat UI pass. It is an operating model for teams who run long agent sessions on multi-root game repos — client Assets/, services, tools, and docs in one window.

This article maps what changed, when to spawn /side instead of interrupting the main agent, how to @mention findings back, how pickers interact with monorepo scope, and how to file cursor_311_side_chat_receipt_v1.json before you call the workflow team policy. For hallucinated-code gates on Unity prototypes, keep our Cursor Unity pair-programming workflow. For terminal permission posture, pair with Claude Code Manual permission mode. For the product lineup, start with best AI coding assistants 2026.

Why this matters now

Three July 2026 facts still collide for game teams at the end of the month — the Jul 10 ship is no longer "news," but the keep/hold for monorepos is:

1. Side Chats are durable agents, not popups — /side, /btw, or the plus button opens a full conversation that inherits main-chat context at spawn, can be revisited later, and can be grafted back with an @-mention. Default posture focuses on reading, searching, and answering so tangents do not silently rewrite scenes.
2. Agent history became searchable — Cmd+K in the Agents Window searches a local index across thousands of past transcripts; Cmd+F jumps matches inside one conversation. That matters when last month's "NullReference in pause menu" thread is the fastest fix for today's Deck build.
3. Pickers finally admit location — This Computer, Cloud, and Remote Machines are separate scopes. Multi-root selection lives inside those flyouts. Wrong-root edits remain a real failure mode — see our multi-root game assets scope fix.

Evidence note: Primary keyword Cursor 3.11 side chats. Cursor remains a top editor-first assistant in professional surveys (JetBrains AI Pulse reported 18% work adoption). SERP gap: changelog mirrors explain features; game monorepos need graft-back rules, read-first side-chat policy, and picker discipline for Assets/ vs services.

Non-repetition: This is not the 14-assistant comparison, not the Unity hallucination pair-programming guide, not the Unity MCP bridge, and not Claude Manual permission governance. Same Cursor brand, different job — parallel conversation ops after 3.11.

Who this guide is for

Time: about 30–45 minutes for the beginner path; add 20 minutes to document team side-chat policy and a receipt.

What shipped in Cursor 3.11 (plain language)

Official detail lives on the Cursor 3.11 changelog. Treat third-party "parallel chat" roundups as orientation only — your monorepo rules are the product.

Beginner path - one evening side-chat smoke

Prerequisites

• Cursor 3.11+ installed and signed in.
• A throwaway branch on a Unity, Godot, or general game repo (never main / release).
• A real agent task already running or ready (for example: "add a pause-menu volume slider in scripts only").
• 30 minutes.

Step 1 - Start a bounded main task

In the main chat, scope tightly:

Edit only Assets/Scripts/UI/PauseMenu.cs (or your Godot scripts/pause_menu.gd). Add a volume slider getter/setter. Do not touch scenes, prefabs, .godot/, or Library/. Stop after one logical change and list every modified path.

Let the main agent begin. Do not interrupt yet.

Step 2 - Spawn a Side Chat mid-flight

When a clarifying question appears, type:

/side

(or /btw, or use the plus button)

Ask a read-only question:

Read only. Does this repo already have an audio bus or volume setting helper? List file paths only. Do not edit files.

Side chats default toward reading and answering — keep them there on night one.

Step 3 - Graft findings back with @mention

When the side chat answers, return to the main thread and @-mention the side chat so the main agent receives the conclusion without you retyping a novel. Then continue the original scoped write.

Step 4 - Search last week's transcript (optional)

Open the Agents Window, press Cmd+K (Mac) / Ctrl+K (Windows), and search for a known past error string from your project. Confirm you can jump to the old thread. That is the July search value — institutional memory without Discord archaeology.

Common beginner mistakes

• Using a side chat to rewrite half the game while the main agent also writes — two writers, one repo, zero discipline.
• Skipping path fences in multi-root workspaces — side chats inherit confusion if the picker is already wrong.
• Treating @mention graft-back as optional — without it, the main agent never learns what you learned.
• Searching transcripts for secrets you once pasted — treat history as sensitive.

Developer workflows - monorepo patterns that stick

Workflow 1 - Read-first side chat, write-second main chat

Promote a side chat to writes only after you paste an explicit path allowlist and confirm git status roots.

Workflow 2 - Unity client + services monorepo

Typical layout:

repo/
  game/Client/Assets/
  services/api/
  tools/
  docs/

Rules:

1. Confirm picker scope is This Computer → the game client folder (or multi-root with game first).
2. Main agent: scripts under Assets/ only.
3. Side chat: "Where is auth token refreshed?" may read services/ but must not edit it unless that is tonight's ticket.
4. Before accept: git status must not show unexpected services/ paths — same gate as our wrong-workspace Agent fix.

Workflow 3 - Godot script vs .godot/ hygiene

Side chat prompt template:

Read only. Map which autoloads touch audio. Ignore .godot/ and .import/. Propose a one-file script change for volume — do not implement.

Main chat implements the single .gd file. Engine verification stays human (headless or one-scene run).

Workflow 4 - Transcript search as incident memory

Search phrases that pay off:

• Exact exception text from Player.log / Output Log
• Package names (Addressables, Input System, Jolt)
• Build labels you stamped in HUD footers
• "Deck" / "Proton" / "WASM" for platform threads

Do not paste API keys into chats you expect to search later. History is a feature and a liability.

Workflow 5 - Cloud hooks (advanced, team only)

Hooks like beforeSubmitPrompt and afterAgentResponse let teams observe or gate cloud agents. Use them for:

• Logging prompt metadata (not secrets) to an internal audit sink
• Blocking known-dangerous path patterns before submit
• Stopping runaway turns after a budget

Do not enable cloud hooks as a substitute for local Manual review on ship branches. Hooks are observability — not a free pass.

Workflow 6 - Unreal Content vs Source split

Typical Unreal layout that breaks naive agents:

repo/
  MyGame/
    Content/
    Source/
    Config/
  Tools/
  Docs/

Rules:

1. Picker: This Computer → MyGame/ (or multi-root with Source/ first if tonight is C++ only).
2. Main agent: one module or one Blueprint path allowlist — never "also tidy Content while you are here."
3. Side chat: "Which subsystem owns online session?" — read Source/ and docs; do not regenerate .uasset binaries from chat.
4. Before accept: git status must not show unexpected .uasset / .umap churn you did not request. Binary asset thrash is the Unreal equivalent of Unity prefab spam.

Pair engine-side MCP allowlists with Unreal Engine 5.8 MCP Claude session when the editor bridge is in play — Side Chats stay conversation ops; MCP stays tool allowlists.

Decision tree - /side vs /btw vs new main agent

Paste this table into Discord once and you have a creator-shareable ritual without teaching gate IDs.

Creator Monday checklist (shareable)

Copy/paste for your team channel:

Cursor 3.11 Side Chat Monday
[ ] Version ≥ 3.11
[ ] Main task path-fenced (one folder / one file set)
[ ] Picker = This Computer (ship work)
[ ] Mid-flight question → /side read-only
[ ] @mention graft-back before more writes
[ ] git status roots look sane
[ ] Optional: Cmd/Ctrl+K search for last week's error
[ ] Receipt filed (or ticket comment with S1–S6)

Creators: this is the Discord-paste version of the gates below — same discipline, less jargon.

Failure modes that burn evenings

Cost and diligence framing (companies)

Side Chats raise productivity and retained context. For partner diligence or publisher IT questionnaires, state:

1. Data handling: Treat agent transcripts as potentially sensitive (paths, stack traces, sometimes secrets if operators paste them). Prefer local index awareness + secrets policy over "the AI remembers forever."
2. Access control: Branch isolation, human merge, engine smoke after agent writes — same bar as any contractor with repo access.
3. Observability: Cloud hooks are optional audit plumbing; they are not a compliance checkbox by themselves.
4. ROI: Measure time-to-clarification (minutes saved when /side answers "where is X?") and regression rate (wrong-root merges per week) — not vanity "messages sent."

JetBrains' April 2026 AI Pulse (10k+ professional developers) puts Cursor in the same work-adoption tier as peer editor agents — useful for "why we standardize" language, not for claiming monopoly. Primary source: JetBrains AI coding tools survey. Feature truth stays on the Cursor 3.11 Side Chat changelog.

Cite-worthy sources (outbound)

Governance gates S1–S6

Diligence paragraph for partners: Cursor is an editor-hosted agent platform. Side chats and transcript search increase productivity and also increase retained conversational context. Treat prompts, paths, and logs as potentially sensitive. Prefer branch isolation, read-first side chats, human merge approval, and engine-side verification. Cloud hooks add observability for managed rollouts; they do not replace code review or MCP/editor undo discipline.

Verification receipt - cursor_311_side_chat_receipt_v1.json

{
  "schema": "cursor_311_side_chat_receipt_v1",
  "project": "your-game-repo",
  "date": "2026-07-30",
  "cursor_version": "3.11+",
  "main_task": "Bounded pause-menu volume slider in scripts only",
  "side_chat_prompt": "Read-only audio helper path map",
  "graft_back_used": true,
  "picker_scope": "This Computer",
  "roots_in_workspace": ["game/Client", "services"],
  "writes_from_side_chat": false,
  "transcript_search_tested": true,
  "gates": {
    "S1_version": true,
    "S2_read_first": true,
    "S3_picker_explicit": true,
    "S4_multiroot_fences": true,
    "S5_secrets_policy": true,
    "S6_receipt_filed": true
  },
  "engine_verify": "play_mode_or_headless_pass",
  "result": "pass",
  "operator": "session-owner-handle"
}

Set "result": "pass" only after human review and engine smoke where relevant.

How Side Chats compare to nearby tools

Troubleshooting

“Side chat edited my backend.” You left write permission too wide. Restart with read-only prompt language and tighten .cursor/rules path fences.

“@mention did nothing useful.” Mention the side chat after it produced a concrete conclusion (file list + recommendation), not mid-research.

“Search cannot find last week's thread.” Confirm you are in the Agents Window Cmd+K index, not a single-chat Cmd+F only. Rebuild by opening recent agent sessions once so they are indexed.

“Picker keeps offering Cloud when I want local Unity.” Explicitly choose This Computer and the local project path before starting the main agent. Do not accept a cloud clone for ship-branch work by accident.

“Two agents conflicted on the same file.” Serial writes: one writer at a time. Park the side chat as read-only until the main chat commits or undoes.

Four reusable game-dev patterns

Pattern A - Architecture question mid-refactor

Main agent rewrites combat damage. Side chat asks which damage types already exist. Graft the enum list back; main agent continues without inventing a parallel type system.

Pattern B - Package version reality check

Main agent proposes Input System code. Side chat confirms which Input System package version the project pins. Prevents hallucinated API from a newer docs page.

Pattern C - Incident replay via transcript search

A Deck build fails with a familiar NullReference. Search last month's transcript for the same stack fragment before starting a new agent from zero.

Pattern D - Cloud vs local isolation

Ship-branch work stays on This Computer. Side chat may research docs; cloud agent hooks stay off until IT approves observability sinks.

Key takeaways

1. Cursor 3.11 (Jul 10, 2026) adds durable Side Chats, transcript search, scoped pickers, and cloud hooks.
2. Use /side or /btw for clarifying questions without derailing the main agent thread.
3. Default side chats to read/search/answer; promote writes only with an explicit path allowlist.
4. @mention side-chat conclusions back into the main thread so graft-back is intentional.
5. Treat This Computer / Cloud / Remote picker scope as a release gate on monorepos.
6. Use conversation search as incident memory — never as a secret store.
7. File cursor_311_side_chat_receipt_v1.json with gates S1–S6 before calling the workflow policy.
8. Pair with Unity contract checks, MCP allowlists, and multi-root help pages — Side Chats are conversation ops, not engine verification.
9. Unreal teams: treat Content binary thrash like Unity prefab spam — scripts/Source first, human owns assets.
10. Use the Monday Discord checklist once, then graduate to the S1–S6 receipt on ship branches.

Frequently asked questions

What are Cursor 3.11 Side Chats?

Side Chats are durable parallel agent conversations you open with /side, /btw, or the plus button. They inherit context from the main chat at spawn, can be revisited later, and can be @-mentioned to pull findings back into the main thread.

How do I use Cursor Side Chats for Unity or Godot?

Keep the main agent on a bounded script edit. Spawn a read-only side chat for architecture or path questions. Graft conclusions back with @mention. Verify in the engine after writes. Do not let two agents write scenes at once.

What is Cursor conversation search?

Cursor 3.11 builds a local search index over agent transcripts. Cmd+K in the Agents Window searches across conversations; Cmd+F searches within one transcript. Useful for recovering past engine-error discussions.

Do Side Chats replace Claude Code subagents?

No. Side Chats are editor-native parallel threads for tangents while a main Cursor agent runs. Claude Code subagents and permission modes are a terminal-first model — see our Claude Manual permission guide.

Can Side Chats edit files?

They are full agent conversations and can edit if you allow it. For game repos, start read-only. Require path allowlists before any side-chat writes, especially in multi-root client+backend workspaces.

How do repo pickers change in 3.11?

Search and selection are scoped by location (This Computer, Cloud, Remote Machines). Multi-root selection is a toggle inside those flyouts. Explicit location choice reduces accidental cloud-vs-local confusion on Unity projects.

Should I use Side Chats for Unreal Blueprints?

Prefer Side Chats for read/search questions (which subsystem owns X?). Keep Blueprint and Content asset edits human-reviewed or MCP-gated. Parallel agents writing .uasset files is how you get unreviewable binary diffs.

What is the difference between /side and starting a new agent?

/side inherits main-chat context at spawn and keeps the original plan alive. A brand-new agent is for a new job or after you fixed a bad picker — not for a one-line clarifying question mid-refactor.

How do Side Chats relate to Unity MCP or Godot MCP?

MCP bridges expose editor tools with allowlists. Side Chats are parallel conversation threads. Use both: MCP for safe editor actions, Side Chats so clarifying questions do not derail the main agent. See Unity MCP with Cursor and Godot AI MCP with Cursor.

Conclusion

Cursor 3.11 is the release that admits agent work is no longer a single chat scroll. Side Chats keep tangents from poisoning the main plan. Conversation search turns last month's engine fire drill into a query. Pickers finally name where the agent is allowed to run.

Tonight: one bounded main task, one /side read-only question, one @mention graft-back, one git status root check, one receipt. Then compare your editor workflow against the broader assistant field before you loosen write permissions on the branch that ships your next demo.

Related reading and sources

• Cursor 3.11 changelog - Side Chats and Conversation Search
• JetBrains AI coding tools survey 2026
• Best AI coding assistants 2026
• Cursor Unity pair-programming workflow
• Unity MCP with Cursor safe session
• Godot AI MCP with Cursor safe session
• Aider AI Coding Assistant Workflow for Game Developers - 2026 — Git-native terminal pair programming (distinct from Side Chats)
• Antigravity CLI Migration for Game Developers - What Changed in 2026 — Google Gemini CLI sunset → Antigravity terminal lane (distinct from Side Chats)
• Claude Code Manual permission mode
• Cursor Agent multi-root Assets scope fix
• 50 free AI tools for game developers