Claude Code Turned `/fork` Into a Background Fleet. Your Terminal Agent Isn't One Chat Anymore.

The July 17 release (2.1.212) changed what /fork does, renamed the old behavior to /subtask, and made /resume pull back sessions you deleted. Underneath the muscle-memory churn is a real shift: the coding agent is now a set of sessions you run in parallel and manage, not a single conversation you babysit.

For most of Claude Code's life, /fork did a small, contained thing. It spun up a helper inside your current chat to go chase a side question and report back. You stayed in one conversation the whole time. The July 17 release reassigned that verb to something much bigger, and gave the old job a new name.

Now /fork copies your entire conversation into a separate background session, its own row in claude agents, and lets it keep running while you keep typing. The in-session helper it used to launch is now /subtask. One rename, two commands, and the mental model of what a terminal coding agent is moves from "a chat window" to "a fleet you dispatch."

That sounds like a footnote in a changelog. It isn't. It's the clearest signal yet of where the whole category is heading, and it's shipping in a tool millions of developers already have installed.

Why a command rename is the actual news

Look at what the same release (Claude Code 2.1.212, July 17, 2026) shipped alongside the /fork change, and the direction stops being subtle.

A per-session cap on subagent spawns, defaulting to 200, tunable with CLAUDE_CODE_MAX_SUBAGENTS_PER_SESSION, added specifically to stop runaway delegation loops. A session-wide limit on WebSearch calls, also 200, for the same reason. MCP tool calls that run longer than two minutes now move to the background on their own so the session stays usable. Completed background agents stay listed in /tasks until you clean them up instead of vanishing the second they finish.

You do not build spawn caps and delegation-loop brakes for a tool people use as a single chat. You build them for a tool where one session can launch many, where work runs in the background out of your sightline, and where a loop can rack up cost while you're looking at a different agent. Anthropic spent a release on session orchestration, not on model quality. The engineering went into managing a fleet, because a fleet is what people are now running.

Here's the position I'll defend for the rest of this piece: the harness is the product now, and session orchestration inside that harness is the feature that actually changes your day. The model matters, but you don't tune it. You tune how many agents you run, what they run on, and how you get back to the ones you parked. This release is free to adopt today, and it repays the friction of relearning your reflexes faster than almost anything else in the tool.

What actually changed, in the order you'll hit it

Start with the rename, because it will trip you first. If you have /fork in a script, a runbook, or a team doc, it now means something different. Old /fork behavior lives at /subtask. New /fork throws a copy of the conversation into the background.

The background session is the real primitive. When you /fork, Claude Code doesn't pause your work to go think. It clones the conversation state into a new session that shows up as a row in claude agents, then hands you back your prompt so you can keep going. The fork runs on its own. If your session has no title yet, the release names the copy after your prompt so the row is recognizable instead of a hash you can't place.

You can park any session, not just a fork. The ← key or /background drops the current session into the background daemon and frees your terminal. The footer hint pulses "N done" when a background agent finishes while you're busy with something else, so you're not blind to completions.

Then there's /resume, which got the genuinely useful upgrade. Type /resume in the agent view and you get a picker of past sessions, including ones you already deleted from the list. Pick one and it comes back as a background session. Sessions you thought you'd thrown away are recoverable, and they return in the same parallel-friendly shape as everything else.

The through-line: dispatch work, keep your hands free, and come back to any of it later. That's fleet management. The terminal used to be a place you had a conversation. It's becoming a console where you watch several conversations you started.

Put this into practice without breaking your week

The lowest-friction first step is the boring one, and it's the whole point: update, then deliberately relearn two commands before you need them under pressure.

Update and check your version. Run claude update, then claude --version. You want 2.1.212 or later. The July 18 patch (2.1.214) fixes several background-session bugs from this exact release, so take the newer build if it's available.
Retrain the rename on purpose. Before you rely on it, run /subtask once for the old in-chat helper behavior and /fork once to see a copy land in the background. Watching a fork appear as its own row is what makes the new model click. Do this on a throwaway session, not mid-refactor.
Fork a long investigation, then keep working. Next time you send the agent after something slow, a "why is this test flaky across the suite" hunt, /fork it. The copy chews on the question in the background while you keep shipping in the foreground. Check claude agents to see it running.
Learn where parked work lives. Park a session with ← or /background, then open the agent view. Get comfortable seeing your sessions as a list you manage. Completed agents sit in /tasks until you clear them, so that's where you go to collect results.
Set the guardrails before you need them. If you're going to run agents that spawn subagents, set CLAUDE_CODE_MAX_SUBAGENTS_PER_SESSION and CLAUDE_CODE_MAX_WEB_SEARCHES_PER_SESSION to values you're comfortable paying for. The defaults are 200 each. That's a lot of billable calls if a loop goes sideways at 2 a.m. /clear resets the subagent budget.

None of this requires a new tool or a new subscription. It's muscle memory and two environment variables. The whole cost of adoption is one throwaway session and ten minutes of deliberately breaking your old habits.

Where it bites

The rename will cost you a day. Every doc, script, alias, and teammate that referenced the old /fork is now subtly wrong, and the failure is silent because both commands still exist and both do something. Nothing errors. You just get the other behavior. Grep your team's runbooks for /fork before someone forks a session they meant to keep in-chat.

The background machinery shipped rough, and the changelog says so out loud. The July 18 patch fixes background sessions that kept the daemon and a worker process alive indefinitely when left idle, completed sessions that were impossible to remove via claude rm, background sessions dispatched from a non-git folder that couldn't be deleted from the agent view, and a displaced daemon deleting its successor's control socket on shutdown. That's a lot of "the fleet got stuck" bugs for one follow-up release. Parallel session management is genuinely hard to get right, and this is version one of it. Expect to occasionally kill a stuck daemon by hand.

The caps are defaults, not limits. Two hundred subagent spawns and two hundred web searches per session is a ceiling most people will never touch, which means for most people it's not really a brake. If you're worried about cost, the number that protects you is the one you set, not the one you inherit.

And the blast radius didn't shrink, it grew. More agents running in parallel, more of them in the background where you're not watching, all with the same filesystem and network access your foreground session has. The orchestration is better. The thing being orchestrated is still software that reads, edits, and runs your whole repo, now doing it in several places at once while you look away.

Who should skip the deep end: if you run Claude Code as a single focused session and never wanted a fleet, you don't have to build one. Adopt the rename so you don't get surprised, ignore the rest, and keep working the way you work. The parallel machinery is there when you want it, not a tax you have to pay.

The part worth sitting with

The interesting question isn't whether to update. Update. It's what you become once your coding agent is a console instead of a conversation.

A single chat keeps you honest by keeping you present. You see every command before it runs because you're right there. A fleet you dispatch and park trades that presence for throughput. You get more done, and you watch less of it happen. The guardrails in this release exist because Anthropic knows that trade has a downside, and they're trying to put brakes on it before it hurts someone.

So the thing to decide isn't whether background sessions are useful. They are. It's how many agents you're willing to have running where you can't see them, and what you're going to do to keep track. Fork the long investigation. Then go read what it did before you merge it.

Sources: Claude Code changelog, versions 2.1.212 (July 17, 2026) and 2.1.214 (July 18, 2026); Claude Code updates, Releasebot.