This guide walks you through three new features in Cursor 3.11: open a side chat to ask questions without interrupting the main Agent, use Cmd+K to search through thousands of past conversations on your local machine, and use Hooks to intervene and monitor sub-Agents at key moments. Includes a fully functional hooks.json example and a cloud-related pitfall to avoid.
(Prior context: Elon Musk’s SpaceXAI has officially launched its most powerful model, 'Grok 4.5'! Partnering with Cursor to aggressively target AI coding agents, seamlessly integrated with Office productivity software.)
(Bonus context: Cursor Mobile is live: A dedicated app that lets you easily use your phone to command AI for coding and monitor outputs)
Main Agent is undergoing a major refactoring, and you suddenly want to check whether a certain function is called elsewhere. Previously, you could only stop it, switch away, and interrupt the running task. The three new features introduced in Cursor 3.11 (released July 10, 2026)—side chat, conversational search, and cloud Agent hooks—perfectly address the need to avoid disrupting the main workflow.
This assumes you're already using Cursor's Agent to walk you through three new features at once, with an example hooks.json and a cloud pitfall to watch out for.
This outline
- Side chat: Keep the main agent running and open a new chat that inherits the context for follow-up questions.
- Search conversations: Cmd+K to search through thousands of local past conversations, Cmd+F to search this current one
- Cloud Agent Hooks: Interject at nodes such as prompt submission, response, and child agent initiation
- How to connect the three features together, and the pitfalls of cloud hooks
Keep the main agent active with side chat, and start a new chat that inherits the context.
Side chat addresses a specific scenario: while the main agent is running a long task, you want to ask a question without interrupting it.
There are three ways to open a side chat—choose the one that works best for you:
- Type the command: In the chat box, enter
/sideor/btw - Click the button: Tap the + button at the top of the chat panel.
The side chat that opens will directly inherit the context of the main conversation, so you don’t need to repost the background—it already knows what you were just working on.
The most common misunderstanding at this step is that the side chat is default-only for reading, searching, and answering—it won’t touch your code. Its purpose is to let you ask follow-up questions, look up information, explore alternative approaches, or perform a quick sanity-check on a decision before taking action, while the main agent continues running unaffected. You must explicitly instruct it to make changes during the conversation.
Each side chat is a complete, permanently stored agent conversation—not something you ask and then discard. You can revisit it later and continue asking questions. When you find useful insights, use @ to bring this side chat back into the main conversation, and the context will seamlessly reconnect to the main thread.
From my own experience, the best use of side chat isn't asking “What is this?”, but rather “The main agent plans to make this change, but I’m concerned it might affect X—could you first check if X is depended on elsewhere?” Let the main line keep moving forward while you verify in the background—keep the two threads from blocking each other.
Use Cmd+K to search through thousands of old conversations on your device, and Cmd+F to search for this current one.
Previously, finding “how that agent resolved the bug in last week’s conversation” meant slowly relying on conversation names or PR numbers—it was painful. With 3.11, search has been integrated, with two levels of filtering.
Search all previous conversations by pressing Cmd+K in the Agents Window.
In the Agents Window, press Cmd+K to open the command palette and search directly within Agent conversation transcripts, not just names or PR numbers. Cursor will build a local search index, so even with thousands of conversations, searches remain fast.
Since the index is built locally, your content is not uploaded to the cloud for searching, which provides greater peace of mind for those concerned about privacy.
Search for this conversation using Cmd+F
If you just need to find a specific part within this long conversation, simply press Cmd+F. It will show you a match counter and allow you to navigate between matches, letting you search while scrolling through long transcripts.
Be careful at this step—the index needs a moment to build after upgrading. If you can’t find old conversations or your chat history appears empty, wait for the indexing to complete before checking again; your data is most likely still there.
Cloud Agent Hooks let you intervene, monitor, and control sub-agents at key moments.
Hooks are the most significant update for developers this time. They allow you to attach your own scripts to key points in an Agent conversation, automatically triggering your code when the Agent reaches those points.
3.11 These newly added nodes cover several key moments in a single Agent conversation:
beforeSubmitPrompt: You have submitted the prompt, but the request has not yet been sent to the backendafterAgentResponse: After the agent has delivered a responseafterAgentThought: After a thinking (thinking) phase has endedsubagentStart: Before spawning a child Agent (Task tool)subagentStop: Sub-agent completedstop: When the entire Agent loop ends and the task is stopped
With these nodes, you can do three things: monitor the entire execution process, control the sub-Agent before and after it starts, and set up an automatic self-correcting loop—for example, running a test immediately after the Agent delivers its response, and if it fails, sending the error back for it to fix itself.
How do you write and where do you place hooks.json?
Hooks are configured in hooks.json, with version fixed at 1. There are three possible locations where they can be placed; all existing ones will be executed:
- Project level:
/.cursor/hooks.json - User global:
~/.cursor/hooks.json - Enterprise level:
/etc/cursor/hooks.json
A minimal working example that does two things: runs an audit script every time the Agent modifies a file, and logs an entry when the task stops:
{
"version": 1,
"hooks": {
"afterFileEdit": [
{ "command": "./hooks/audit.sh" }
],
"stop": [
{ "command": "./hooks/on-stop.sh" }
]
}
}The path in the command is relative to the location of hooks.json. Your script will receive a JSON object via stdin (standard input) containing the basic fields conversation_id, generation_id, model, and hook_event_name, along with additional fields specific to the node, such as prompt for beforeSubmitPrompt and response text for afterAgentResponse.
A script that does nothing but confirm it can receive data looks like this:
#!/bin/bash
cat > /dev/null # consume stdin
exit 0 # report successTo block an action, only two nodes must approve.
There’s a common pitfall here: not every hook can intercept actions. Only beforeShellExecution (before running a shell command) and beforeMCPExecution (before calling an MCP tool) check your stdout (standard output) JSON to determine whether to allow or block the action:
{
"continue": true,
"permission": "allow",
"userMessage": "Message shown to you",
"agentMessage": "Message shown to the AI"
}For permission, set allow to permit, deny to block, or ask to prompt you. Other nodes, such as afterAgentResponse, will not respond to a permission setting—they can only observe, log, or trigger other actions, but cannot block.
Common pitfalls of cloud agents
If you use Hooks with a cloud agent, one node will directly fail: beforeSubmitPrompt. The reason is practical: this hook is tied to the beginning of the session lifecycle, but the cloud virtual machine (VM) is only created after the session has started. At the very beginning of the session, the machine doesn’t exist yet, so there’s nothing to execute this hook.
From my own experience, when using the cloud, stick to nodes tied to "before and after tool execution," such as beforeShellExecution, afterFileEdit, subagentStart, subagentStop, and stop—they’re more reliable. Don’t count on nodes tied to the very beginning of a session.
Link three features together
The three features are clearly explained individually, but you should try combining them yourself to experience how they work together. Here’s a real-world scenario:
The main Agent is running a refactoring across multiple files. You open a side chat (/side) to check “how many places are using this interface to be modified,” while the main thread continues. After checking, you identify risks and use @ to bring the side chat’s conclusions back into the main conversation, prompting the main Agent to handle all those locations together. Meanwhile, you have a stop node configured in your hooks.json that automatically runs tests once the refactoring is complete, and you then use Cmd+F to revisit this long conversation and locate which functions the Agent mentioned it modified.
You completed everything you wanted to do without being interrupted.
Appendix: Additional Resources
- Cursor Official Changelog: Complete release notes for each version; the side chat and conversation search in 3.11 are covered here.
- Cursor Hooks Official Documentation: Complete reference for all hook nodes, stdin/stdout fields, and configuration formats
- Cursor Subagents Documentation: Refer to this when using subagentStart/subagentStop nodes
Frequently Asked Questions
Q1. Will the side chat modify my code?
A: By default, no. It only performs three actions: reading, searching, and answering; its purpose is to help you verify and ask follow-up questions. To have it make changes, you must explicitly request it during the conversation.
Q2. Will the side chat disappear if I turn it off?
A: No. Each side chat is a fully preserved, long-term Agent conversation that you can revisit later, follow up on, or bring back to the main chat using @.
Q3. Is the Cmd+K chat search searching the cloud or locally?
A: Local. Cursor builds a search index on your local machine; your content is never uploaded for searching, and it remains fast even with thousands of conversations.
Q4. After upgrading, your old conversations can’t be found or the chat history is empty?
A: The local index is probably still being built—wait for it to finish before checking again; it’s usually not a data loss issue.
Q5. What are the differences between hooks in the cloud agent and locally?
A: The main issue is that beforeSubmitPrompt doesn't work in the cloud because the cloud VM hasn't been initialized yet when the session starts. Nodes tied to the tool's execution前后, such as beforeShellExecution, afterFileEdit, and subagentStart, are more stable in the cloud.
Q6. Where should hooks.json be placed to take effect?
A: The project’s .cursor/hooks.json, the user’s global ~/.cursor/hooks.json, and the enterprise’s /etc/cursor/hooks.json — any of these that exist will be executed.
Q7. Can I have hook directly block a dangerous command?
A: Yes, but only the beforeShellExecution and beforeMCPExecution nodes recognize the permission returned in your stdout—setting it to deny will block the action. Other nodes can only observe and trigger actions, but cannot block them.
📍Related Articles📍
Perplexity自救！決心殺入vibe coding賽道，放話工程師不用看程式碼
Cleaning up Vibe coding technical debt is becoming a new way to make money in the AI era.