Your team adopted the coding agent. Did they adopt the delegated workflow?

I read coding-agent release notes the way some people check the weather. It is a low-effort way to know which direction the wind is blowing. This week the wind was blowing in one very specific direction, and it was not toward a smarter model.

Between July 2 and July 4, Anthropic shipped Claude Code v2.1.198 through v2.1.201. Four versions in three days. I went looking for a new capability and found something more revealing: a daemon that had been killing itself and every running agent roughly every fifty seconds after an unclean shutdown, background sessions that silently stopped mid-turn after a laptop went to sleep, and subagents that threw away their partial work the moment they hit a rate limit. Over in GitHub’s Copilot CLI, v1.0.68 and v1.0.69-0 on July 1 and 2 spent their energy keeping the session alive through a flaky IDE connection and not running out of memory inside a large monorepo. Almost none of it was model news. All of it was plumbing for one thing: getting a coding agent to run when nobody is watching it.

That distinction is the whole game right now, and it is hiding underneath every adoption number on the slide.

Four days, four Claude Code releases, almost all about agents that quietly die

Here is what those release notes actually described, in the vendors’ own words. Claude Code v2.1.198, on July 2, taught background agents launched from claude agents to commit, push, and open a draft pull request when they finish work in a worktree. Good. That is the delegated workflow the whole category has been selling. The very same release also fixed the background-agent daemon on Linux killing itself and every running agent every fifty seconds or so after a corrupted worker record.

The next day, v2.1.199 fixed streaming responses being discarded when the API hit a mid-stream error after partial output, so the partial is now kept. It fixed subagents cut off by a rate limit silently failing instead of returning their work to the parent. It fixed subagents reporting API errors as if they had succeeded. Then v2.1.200 fixed background sessions silently stopping mid-turn after sleep or wake, and it flipped the default permission mode to Manual across the CLI, VS Code, and JetBrains.

None of that reads like a launch. It reads like a confession about where the real friction lives.

The workflow your team said it adopted: hand off the ticket, walk away

Every adoption deck I see now tells the same story. The win is no longer autocomplete. The win is delegation. Hand the agent a scoped ticket, let it work on a branch, come back to a draft pull request to review. Background agents, cloud agents, whatever the vendor calls them, they all promise the same shape of work. You stop typing alongside the machine and start assigning to it.

The tooling this week was built precisely for that promise. An agent that commits, pushes, and opens a draft PR on its own is the delegated loop closing. When a leader tells the board the team adopted Claude Code or Copilot, this is the picture in their head: engineers steering three or four agents at once, reviewing the output, shipping more.

And on the dashboard, that adoption is real. The seat is active. The tool is in the workflow diagram. The license utilization report is green. I want to be careful here, because this is the part that fools smart people. Everything measurable says the workflow changed.

The failure modes that push engineers back to babysitting the agent

Now put yourself at the desk instead of the dashboard. An engineer hands off three tickets before lunch, trusting the delegated loop. They come back to find the daemon restarted itself and quietly ate all three runs, with no error to explain it. Or the laptop slept during a meeting and the background session stopped mid-turn without a word. Or the agent hit a rate limit and reported success while actually returning nothing.

Nobody files a bug for that. That is the important part. They just stop delegating. They go back to the foreground: agent in one pane, eyes on every step, approving each edit, babysitting. It feels safer, and after being burned twice, it is the rational choice. The seat stays active. The workflow change evaporates. Adoption and the actual change in how work gets done have quietly divorced, and the only signal on the dashboard is still green.

Copilot’s July releases tell the same story from the other side of the fence. Keep the IDE tools available through a transient disconnect and return a clear error instead of dropping the whole session. Fall back to ripgrep when the monorepo indexer runs out of memory. This is not a capability race. It is a reliability race, because reliability is the precondition for the delegated workflow to survive contact with a real week.

The tell that the vendors know this is the Manual default. When Claude Code changes its default permission mode to Manual across every surface, it is making unattended autonomy something a team turns on deliberately rather than inherits by accident. That is the right call. It is also an admission that the trust required for delegation is not there by default yet.

There is a second gap sitting underneath all of this, and it is not about reliability at all. It is about comprehension. Even when the delegated loop works perfectly and a clean draft PR lands, someone has to understand what came back.

Fifty-seven percent said juniors understand it “to some extent” and twenty-three percent said “rarely.” So delegation can succeed at the plumbing level and still fail at the level that matters, because the person receiving the agent’s output cannot vouch for it. A draft PR that nobody genuinely understands is not a productivity gain. It is a review debt with a due date.

Why adoption counts seats while the value sits one layer down

Here is the reframe I would put in front of an engineering leader this quarter. Adoption is a seat number. It answers “is the tool switched on.” The workflow value depends on two conditions that no adoption percentage can see.

First, is the delegated mode reliable enough that people actually trust it unattended. Second, when the agent hands work back, does a named human understand and own it. Miss either one and you get the thing that keeps showing up in the data: teams that adopted the tool, moved faster on paper, and did not change the outcome the way they hoped.

The productivity-paradox numbers are just this gap measured after the fact. Faros AI’s enterprise data from the spring showed teams producing far more pull requests, up around 98 percent, while pull-request review time stretched roughly 91 percent longer and code churn climbed. That is the fingerprint of adoption without a changed workflow: more artifacts moving through the pipe, more time spent verifying them, and the same delivery coming out the far end.

Adoption is the moment the agent turns on. It is not the moment the work changes. Those are two different dates, and most dashboards only show the first one.

That is oddly good news, though. It means the lever is findable. The problem is not that coding agents do not work. It is that “adopted” was measuring the wrong layer, and the right layer is one you can instrument.

What I’d check before I trust another “we’ve adopted it” slide

Three moves, and none of them require a new tool.

First, stop reporting seat activation as the win and start measuring the delegated loop. How many background or handed-off runs finished and produced a reviewable draft PR, versus how many died, stalled, or got quietly abandoned. That ratio is the real adoption number. If most delegated runs are being abandoned, the team is babysitting, and no license report will tell you.

Second, name who owns the output per service area. A draft PR from an agent that nobody is accountable for reviewing is worse than no PR, because it looks like progress. Pair the delegated work with a specific human who can vouch for what merges, especially where juniors are handing up code they may only partly understand.

Third, get onto the version where the background layer actually holds, and treat the Manual default as a decision to make on purpose. Turn unattended autonomy on deliberately, for the workflows where the reliability is proven, and leave it off where it is not.

Adoption was never the finish line. It was the moment the interesting work started: turning a tool that is switched on into a workflow a team can trust, and can explain. The vendors spent the first week of July fixing the plumbing for exactly that. The rest is ours to build, and it is the calm, figure-out-able kind of work, not the scary kind.