- In short
- Choosing between restart and summarise turns on whether the thread should continue. Restart fits a session that has drifted beyond recovery or a task that is genuinely new within the same workstream. Summarise fits a session where the thread should continue but the current context window is already degraded. In a Project, standing instructions and the knowledge base carry forward automatically on restart, but the conversation thread does not, so summarising is how thread continuity is preserved.
The decision between two of the three responses
The three responses to context degradation include two that are easy to confuse: restart and summarise. The CCAO-F exam tests, at the analyse level, the finer judgement of choosing between them, because picking the wrong one has a specific, opposite cost in each direction. The deciding question is whether the thread should continue.
If the thread's content is worth carrying forward, you summarise so continuity survives the move to a fresh window. If the thread has drifted beyond recovery, or you are genuinely starting a new task, you restart clean. The two are not interchangeable: restart discards the thread, summarise preserves it, and the right choice depends on whether the thread deserves to be preserved. This analysis feeds directly into the long-session diagnosis.
- Choosing between restart and summarise
- The judgement of which response fits a degraded session. Restart fits a session drifted beyond recovery or a genuinely new task within the workstream. Summarise fits a session whose thread should continue but whose window is degraded. In a Project, standing instructions and the knowledge base carry forward on restart automatically, but the conversation thread does not -- so summarising is how thread continuity is preserved.
When to restart
Restart is right in two situations. The first is when the session has drifted beyond recovery: the context has degraded so far that the thread's recent content is unreliable, and continuing from it -- even via a summary -- would carry that unreliability forward. A clean restart cuts the drift loose. The second is when you are beginning a genuinely new task within the same workstream, where the previous thread's specifics are not needed and starting fresh is simply cleaner.
In both cases, restarting inside a Project is low-cost for the stable context, because the Project's standing instructions and knowledge base carry forward into the new conversation automatically. What does not carry forward is the conversation thread itself. So restart is the natural choice precisely when the thread's content is either unwanted (new task) or untrustworthy (drifted beyond recovery), and the automatically-carried Project context is enough to continue.
When to summarise
Summarise is right when the thread should continue but the current window is degraded. Here the substance of the thread -- the decisions, the in-progress work, the open questions -- is still valuable and reliable; the problem is only that the window has filled and started compressing early content. Summarising captures that substance and carries it into a fresh conversation, giving you a clean window with the thread's continuity intact.
This is exactly where the Project detail bites. Because the conversation thread does not carry forward automatically on restart, a plain restart would lose the thread's content. Summarising is the mechanism that bridges that gap: it turns the thread's substance into portable context that a fresh conversation can start from. So when continuity matters, summarise before you restart; the summary is what makes the restart non-destructive to the work. The line between what to carry in a summary and what to persist more durably connects to memory persistence.
What the CCAO-F exam trips candidates on
Two errors are tested, and they are mirror images. The first is restarting a still-coherent session unnecessarily, losing useful in-session context that did not need to be discarded. If the thread was still reliable and worth continuing, a bare restart throws away good work that summarising would have preserved.
The second is summarising a session that has already drifted so far that the summary itself would carry the same errors forward. When the thread is unreliable, its summary is unreliable too, so summarising propagates the drift into the next conversation. The credited reading matches the response to the thread's state: summarise a coherent thread worth continuing, restart a drifted or finished one.
Worked example
Two long sessions each need a fresh window. In session A, the work is coherent and reliable, with valuable decisions and half-finished analysis; the window is just full. In session B, the conversation has gone badly off track, with several confused and contradictory turns, so its recent content is untrustworthy. For each, restart or summarise?
The two sessions differ on the one axis that decides the choice: whether the thread's content is worth and safe to carry forward. Read each on that axis.
Session A's thread is coherent and reliable, and it holds valuable decisions and half-finished analysis; only the window is degraded. This is the summarise case. Capturing the decisions, the in-progress analysis, and the open questions, then starting a fresh conversation from that summary, preserves the continuity while clearing the full window. A bare restart here would be the first trap -- discarding good, reliable work that did not need to be thrown away, since the conversation thread does not carry forward on its own.
Session B's thread has drifted beyond recovery: several confused, contradictory turns make its recent content untrustworthy. This is the restart case. Summarising it would be the second trap, because a summary of unreliable content is itself unreliable and would carry the drift and contradictions into the new conversation. A clean restart cuts that drift loose. If B is inside a Project, the standing instructions and knowledge base still carry forward automatically, so the restart keeps the stable footing while dropping only the corrupted thread.
So A summarises and B restarts -- opposite responses, chosen by the reliability and value of each thread, not by the fact that both merely need a new window.
Common misreadings to avoid
Misconception
If a window is degraded, the cleanest move is always a fresh restart.
What's actually true
Misconception
Summarising is always safe because it preserves the thread.
What's actually true
How this shows up on the exam
Questions describe a degraded or ending session and ask whether to restart or summarise, sometimes contrasting a coherent thread with a drifted one. Decide on two questions: should the thread continue, and is it still reliable? A reliable thread worth continuing is summarised; a drifted or finished one is restarted. Remember that a Project's stable context carries forward on restart while the thread does not.
This knowledge point refines the three responses, builds on recognising degradation, and unlocks the long-session diagnosis.
Session A is coherent and reliable with valuable half-finished work but a full window; session B has drifted badly with contradictory turns and untrustworthy recent content. What is the right response to each?
People also ask
Should I restart or summarise a degraded Claude session?
What carries forward when I restart in a Project?
What happens if I summarise an already-drifted session?
Watch and learn
Official Anthropic Academy lessons first, then hand-picked walkthroughs. Videos load only when you press play.
No videos curated for this concept yet
We are still curating the best official and community videos for this topic.
Official prep for this domain
Anthropic's own free prep module for this part of the syllabus, on the official prep course. Free with an Anthropic Academy sign-in.
References & primary sources
Master this concept with Archie
Practice it inside an adaptive study session. Archie, your Socratic AI tutor, tracks your mastery with Bayesian Knowledge Tracing and schedules the perfect next review.