Cursor 3.11 introduced side chats: parallel, persistent agent conversations that open with /side, /btw or the + button, run alongside the main thread without interrupting it, and can be re-mentioned with @ to bring their findings back to the conversation that matters. It also adds agent transcript search from the command palette (a local index that scales to thousands of conversations with snappy performance), Cmd+F with a match counter, and hooks for cloud agents (beforeSubmitPrompt, afterAgentResponse, afterAgentThought, stop, subagentStart).
You're halfway through a task with your AI agent, everything is flowing, and suddenly a side question hits you: wait, how was this feature wired up before. You ask it in the same chat, the agent switches topics, and by the time you want to get back to what you were doing the original thread has dissolved into a tangent that had nothing to do with it. That small everyday mess has a name in Cursor 3.11, and a fix too: they're called side chats. They're parallel, persistent agent conversations that run alongside the main chat without derailing it, and their arrival marks a shift in mindset about what an AI-powered IDE actually is.
A chat that's no longer one chat, but many
A side chat opens in three ways: the /side command, the /btw shortcut, or a + button at the top of the chat panel. The idea, in the words of the official note, is to let you ask questions, explore ideas and investigate tangents without interrupting your main conversation with the agent. And here's the most elegant part: you can re-mention it with an @ to bring back to the main thread whatever you discovered in the tangent. It's the difference between opening a mental tab that gets lost and opening a real tab that stays alive and that you can cite. The AI's chat stops being a single line of conversation and becomes a tree of threads you branch and reincorporate at will.
Finding what your agent said a thousand conversations ago
The other big addition solves the twin problem: history amnesia. Cursor 3.11 adds agent transcript search from the command palette, backed by a local search index that, according to the official note, scales to thousands of conversations with snappy performance. Within each conversation you also get the classic Cmd+F, now with a match counter and navigation between results as you scroll through long transcripts. And for anyone orchestrating cloud agents there are new hooks beforeSubmitPrompt, afterAgentResponse, afterAgentThought, stop and subagentStart that let you observe and control the agent's own conversation: its prompts, its responses, its reasoning, its subagents and the close of each turn. Taken together these aren't scattered features: they're the infrastructure of someone who assumes you're going to have many agents talking at once.
The real pain underneath: your AI loses its memory
If you scratch a little, all these pieces attack the same enemy. An agent's value lives and dies by its context: the moment a thread gets contaminated with ten tangents, the model starts mixing up goals, forgets the original instruction and its answers degrade. Losing the thread isn't an aesthetic nuisance, it's a measurable loss of quality. What Cursor does with side chats is give the developer an ergonomic mechanism to protect that context: exploring in parallel without poisoning the conversation that matters, and then deciding which discoveries deserve to come back to the main thread via @. Transcript search is the other side of the same coin: long-term memory so that what an agent solved last week doesn't evaporate. AI editors are shifting away from competing over who has the best autocomplete and toward competing over who manages the context of several live agents best.
What it means for anyone building with AI
The lesson Cursor 3.11 leaves goes beyond the coding audience: the future of working with AI isn't having one conversation, it's orchestrating several without losing the thread of any. The ergonomics that win aren't those of whoever types fastest, but of whoever doesn't let their context get dirty. At NeuralOS that same principle lives in the multi-tab environments and the library: every app, design or automation you build keeps its own thread and its own state, so that opening a new front doesn't erase the previous one and you can return to any of them exactly as you left it. We're not selling you that we invented this — the idea of protecting context by branching it is common sense and we see it flourishing across the whole sector — but it is the same underlying conviction: a serious AI-building tool is measured by how many live threads you can hold at once without any of them losing their memory.