Feature request for product/service
Cursor IDE
Describe the request
Add a one-click action in Agent/Composer chats to start a new conversation that automatically references the current one — like “fork and continue,” but optimised for context hygiene rather than branching exploration.
The problem
Long feature work in a single Agent chat is productive — until it isn’t.
You’ve been iterating on the same thing for an hour. The thread has tool calls, dead ends, tangents, and three versions of the plan. You can feel the context window filling up. The agent starts:
- Re-litigating decisions you already made
- Mixing unrelated threads (“blur creep”)
- Expanding scope because old context is still “live”
- Getting slower and less precise as the window gets crowded
At that point, the right move is usually: start a new chat. Same feature, same repo, same goal — but a tight, fresh context window.
The problem is that the manual version of this is awkward.
Why “just open a new chat” doesn’t scale
Most of us already know we should reset when a thread gets heavy. What we don’t have is a low-friction, reliable way to carry continuity forward.
Today, continuing work in a new chat typically means:
Opening a new Agent tab
- Trying to remember what this old chat was called
- Hunting through hundreds (or thousands) of past conversations with titles like Fix auth bug or Refactor pack station
- Hoping @Past Chats / search finds the right one
- Writing a preamble: “We were working on X, decisions so far are Y, ignore Z…”
That friction has a cost:
- You delay the reset and let the bloated thread run longer
- You lose thread lineage — the new chat doesn’t know it’s a continuation
- You mis-reference the wrong chat because titles are ambiguous
- You re-explain decisions the agent already had in the parent thread
- None of that is a model problem. It’s a workflow and navigation problem.
Proposed solution
A button in the chat chrome — something like:
Continue in fresh chat
Start a new Agent conversation linked to this one.
One click should:
- Open a new Agent chat with an empty, tight context budget
- Automatically attach the parent conversation as a first-class reference (not something you have to hunt for)
- Seed the new chat with a lightweight handoff so the agent knows: what you were doing, what was decided, what changed in the repo, and what to treat as authoritative vs. historical noise
- Preserve a visible parent ↔ child link in both chats (breadcrumb, sidebar, or metadata) so you can navigate back without search
Think of it as: new chat, same thread of work — the interface encodes the relationship you already want in your head.
What the UX could feel like
In the current chat (parent):
- Overflow menu or inline affordance when context is getting heavy:
Continue in fresh chat - Optional hint when the thread is long:
“This chat is large. Continuing in a fresh chat can improve focus.” - After spawn: parent shows something like
Continued in: [Pack station QC — take 2]
In the new chat (child):
-
Opens with a compact handoff block, e.g.:
- Parent chat linked and summarized
- Current goal / next step
- Locked decisions
- Relevant files and diffs from the parent session
-
Composer input still works normally — you can @ files, docs, rules, and other past chats on top of the parent link
-
Title auto-suggested:
-
Pack station QC (continued from …)
-
In history/search:
- Chats show lineage: parent → child
- Filter: “continuations of this chat”
- Search ranks linked threads together
Why this fits Cursor specifically
Cursor already leans into agentic, long-running work: multi-file edits, tool loops, planning skills, debugging canvases. That’s exactly the shape of work that outgrows a single context window.
The product already has pieces of the story:
- @ references for files, rules, and past context
- Chat history and search
- Agent vs. Ask modes
- Long threads with tool output
What’s missing is the intentional lifecycle moment:
“This thread served its purpose; continue the same work in a clean room.”
That’s different from:
- Duplicate chat (same bloated context)
- Generic new chat (continuity is manual)
- Checkpoint / summarize only (still one crowded thread)
Benefits
For the user
- Reset context without losing the thread
- No archaeology in chat history
- Less scope/blur creep
- Easier to resume days later via lineage
For the agent
- Smaller, sharper working set
- Clear parent summary vs. live task
- Fewer contradictions from stale turns
- Better “what matters now” signal
For teams and power users with large chat libraries, lineage also turns ambiguous titles from a liability into a navigable graph.
The best agents aren’t just the ones with the biggest context windows. They’re the ones where the right context is in the room at the right time.
A “continue in fresh chat” button would make that rhythm explicit: keep the work, drop the baggage, and never lose the thread — even when you have a thousand ambiguously named conversations behind you