Claude Code Background Sessions & /fork: The Complete 2026 Guide

If you've been running Claude Code in a single terminal tab, babysitting one task at a time, that workflow just became obsolete. In its mid-July 2026 release wave, Anthropic shipped background sessions for /fork, a smarter /resume flow, and a set of reliability fixes that let long-running agent work survive restarts, daemon crashes, and even a closed laptop lid. Together, these changes turn Claude Code from a single-threaded pair programmer into something closer to a small team of agents you can dispatch, check on, and resume whenever you want.

This matters for anyone building with Claude professionally — and especially for developers preparing for the Claude Certified Architect (CCA) exam, where agentic workflow design and session management show up directly in the objectives. Below is what shipped, how it actually works, and how to start using it today.

What Changed: Background Sessions, /fork, and /resume

The core idea behind this release is simple: agentic coding work is rarely a single conversation. You start a task, realize you need to explore two different approaches, or want Claude to keep working while you do something else. Previously, Claude Code forced you to choose — stay in one session or lose your place. The new release removes that trade-off.

/fork now spawns a background session. Running /fork copies your current conversation into a brand-new background session — its own row in claude agents — while your original terminal session keeps running uninterrupted. Instead of forking a conversation and immediately losing the thread you were on, you now get two independent lines of work: the one you're actively watching, and one running quietly in the background that you can check on later. Background sessions survive real-world interruptions. Long-running commands and workflows now persist through the session's process being stopped, restarted, or updated. On Windows specifically, background shells are handed off rather than killed when the parent process cycles — a fix for a failure mode that used to silently kill hours of agent progress. If a daemon restarts and kills a worker mid-task, Claude Code now automatically resumes that worker from where it left off the next time you open the agents view, instead of leaving it dead in the list. /resume got noticeably smarter. A bug where /loop hid a session from /resume after a single use has been fixed, and Anthropic tightened up session resumption performance generally — resuming a long session with a large context history is faster and more reliable than it was even a few weeks ago. Completed sessions no longer disappear. Previously, a background agent that finished its task would vanish from /tasks the moment it completed, which made it easy to lose track of what actually got done. Now, completed background agents stay listed until you explicitly clean them up, giving you a real audit trail of what ran and when. Reopening a stopped session no longer fails silently. If you try to reopen a background session that stopped for some reason, Claude Code used to just... not do anything. Now it either resumes the session properly, or tells you exactly why it can't and gives you the option to force a restart.

Why This Matters for Real Development Work

None of this is a cosmetic UI tweak — it changes how you should structure work in Claude Code.

Parallel exploration becomes cheap. Say you're debugging a flaky test and have two hypotheses. Instead of trying one, reverting, and trying the other, you can /fork at the decision point, let one background session pursue hypothesis A while you drive hypothesis B in your main session, and compare results side by side. This is the same pattern power users have been using with worktree-isolated subagents — /fork just makes it a first-class, zero-setup feature. Long migrations survive your workday. A dependency upgrade, a large refactor, or a multi-file rename that used to require you to keep a terminal window open (and your laptop awake) for hours can now run as a background session that survives sleep, restarts, and process updates. You kick it off, close your laptop, and check claude agents when you're back. You get an actual record of what ran. Because completed sessions persist in /tasks instead of disappearing, you can now treat your agent history like a lightweight changelog — useful when you're trying to reconstruct what an agent did three hours ago, or when you're reviewing a teammate's agent-driven changes before merging.

How to Use Background Sessions and /fork Today

Here's the practical workflow:

Start your main task as usual. Open a Claude Code session and describe what you want built or fixed.

Fork at a decision point. When you hit a fork in the road — two possible approaches, or a task you want to delegate while you keep working — run /fork. Your current conversation is copied into a new background session; your original session keeps going untouched.

Check on background work with claude agents. This command lists every background session, including its status (running, stopped, completed) and how long it's been active.

Resume anytime with /resume. If you step away or your terminal closes, /resume will pick your session back up — including background sessions that were previously hidden after a /loop call, which is now fixed.

Review completed work in /tasks. Once a background session finishes, it stays visible in /tasks instead of vanishing, so you can review the diff, check for errors, and decide whether to merge before cleaning it up.

Force-restart if something looks stuck. If a session shows as stopped but won't reopen cleanly, Claude Code will now tell you why instead of failing silently — use that message to decide whether to force a restart.

A practical example: you're mid-refactor and want to try converting a module to a different state-management pattern without derailing your current session. Run /fork, let the background session attempt the conversion while you keep working on the original task in your main window, then check claude agents fifteen minutes later to see if the fork's approach is worth adopting.

Where This Fits in the Bigger Claude Code Release

This background-session work landed alongside a broader July 2026 update that also tightened safeguards around WebSearch, subagent spawns, and Bash execution inside Claude Code, plus reliability fixes across MCP connections, worktrees, and remote sessions. Anthropic has also been extending the "keep working while Claude works" philosophy elsewhere in the product — Claude Cowork recently expanded to mobile and web so sessions and files follow you across devices, and Claude Sonnet 5 became the new default model for Free and Pro users on July 1, giving background sessions a faster, more agentic model to run on by default.

The pattern across all of these releases is consistent: Anthropic is optimizing Claude Code for asynchronous, parallel, multi-session work rather than a single linear chat. If you're building an agentic development workflow — or studying agent architecture patterns for a certification — this is the direction to build toward, not against.

Common Mistakes to Avoid

Forking too late. If you fork after a session has already gone deep into a bad approach, both branches inherit the same bad context. Fork at the decision point, not after you've committed to a path.
Losing track of background sessions. With completed sessions now staying in /tasks, there's less excuse for this — but it's still worth periodically running claude agents to see what's actually running versus what you think is running.
Treating background sessions as fire-and-forget. They're resilient to restarts, not to bad instructions. A background session with a vague prompt will produce vague results just as reliably as a foreground one — it'll just take longer for you to notice.
Not reviewing before merging. Because background work happens out of sight, it's tempting to skip review. Treat every completed background session's output the way you'd treat a pull request from a fast, occasionally overconfident teammate.

Key Takeaways

/fork now creates a true background session, letting you branch a conversation without abandoning your current one.
Background sessions survive process restarts, daemon crashes, and — on Windows — background shell handoffs, so long tasks no longer die silently.
/resume is faster and more reliable, including a fix for sessions that used to get hidden by /loop.
Completed sessions persist in /tasks instead of disappearing, giving you an audit trail of agent work.
This release is part of a broader Anthropic push toward asynchronous, multi-session agentic workflows across Claude Code, Cowork, and the default Sonnet 5 model.

Next Steps

Session and agent management is a recurring theme on the Claude Certified Architect (CCA) exam — understanding how to structure multi-session agentic workflows is exactly the kind of practical skill it tests. If you're preparing for the certification, work through AI for Anything's CCA practice tests to see how these concepts show up in exam-style questions, or browse our Claude Code guides for more tutorials on getting the most out of agentic development.

Sources: