Claude Opus 4.7 Programmed a Robot Dog 20x Faster Than Humans, Then Couldn't Fetch the Ball

TL;DR

Anthropic's Frontier Red Team just published Project Fetch Phase Two, and it is the cleanest agentic-uplift data point we have seen this year. Claude Opus 4.7, running autonomously inside Claude Code, programmed an off-the-shelf robot dog roughly 20 times faster than the best human team from a year earlier, and it did so with about a tenth of the code. The twist: it still could not get the dog to actually fetch the ball. The brains scaled. The hands did not.

What Anthropic actually tested

Project Fetch is the Frontier Red Team's running experiment in measuring how much Claude uplifts a non-expert at a hard real-world task. The task is deliberately dumb and physical: get a quadruped robot ("robodog") to find a beach ball and bring it back.

Phase One, run back in November 2025, was a baseline. Two teams of four Anthropic employees, none of them roboticists, raced to control the robot. One team had Claude, one did not. It was mostly a familiarization round and not a serious capability test.

Phase Two, published June 18, 2026, is the interesting one. This time the comparison is not human versus human. It is fully autonomous Claude Opus 4.7 versus last year's best human team that was itself assisted by Claude Opus 4.1. In other words: this year's model running solo against last year's humans-plus-model combo. The humans were the easy mode.

The setup was deliberately hands-off

For the autonomous run, the human role shrank to almost nothing. A researcher plugged a laptop running Claude Code into the robodog, typed the initial prompt, then did little more than approve commands and approve the model moving on to the next task. Claude had to do the rest: connect to the robot's video camera and lidar sensor, detect the beach ball, write its own programs for both manual and programmatic control, and monitor the robot's path.

This is the part builders should sit with. The loop was: prompt, approve, approve, approve. The model wrote the integration code against real sensor hardware it had never seen, on the first pass, with a human acting as little more than a permission button.

The numbers that matter

On the four tasks every participant completed, Opus 4.7 working alone was more than 18 times faster than Team Claude (the assisted humans), which rounds to the headline "about 20x faster." That is the speed story. The code-volume story is arguably more striking:

• Opus 4.7, autonomous: 1,045 lines of code, working on essentially the first try.
• Team Claude (humans + Opus 4.1): 10,309 lines, with iteration and debugging.
• Team Claude-less (humans, no AI): 1,136 lines.

Read that again. The autonomous model wrote roughly one tenth the code of the assisted human team and got a better result faster. The unassisted humans actually wrote tighter code than the AI-assisted humans, which is its own quiet indictment of how people pad and thrash when a chatbot is in the loop. The lesson is not "AI writes more code." It is that an agent driving the whole task end to end converges on a lean solution, while a human copy-pasting suggestions accretes cruft.

And then it failed

Here is the headline nobody at a robotics startup wants to hear, and the one Anthropic published anyway. Opus 4.7 could not complete the actual fetch. It correctly identified where the ball was and positioned the robot to knock it back toward the start, but the real-time motion control fell apart. In the team's words, the efforts "were poorly controlled and not successful." The ball stayed put.

This is the whole point of the experiment, and it is why the result is credible rather than hype. The gap between writing correct software fast and closing a tight real-time control loop on physical hardware is exactly where current frontier models live. Symbolic, code-shaped problems? Crushed, and faster every model generation. Continuous, latency-sensitive, error-correcting motor control? Still wide open.

Why a builder should care

Strip away the cute robot dog and this is a controlled measurement of agentic uplift on an unfamiliar, end-to-end engineering task, run by the people most incentivized to look for danger signs.

1. The uplift is real and it compounds per model generation

The comparison is not "AI versus a beginner." It is this year's autonomous model versus last year's experts who had last year's model helping them. A roughly 20x speedup across one model generation, on a task involving hardware integration and sensor fusion, is the kind of slope that should reset your assumptions about what an agent can be handed unsupervised.

2. Less code, not more, is the tell of a capable agent

If your internal "is the agent actually good" metric is lines produced, flip it. The strongest run here was the leanest. An agent that owns the full task tends to write less and iterate less, because it is reasoning about the whole problem instead of locally autocompleting a human's half-formed plan.

3. The embodied gap is your moat (for now)

If you build in robotics, drones, hardware-in-the-loop, or anything with a real-time physical control surface, this is your reprieve. The reasoning and integration layers are getting automated fast. The closed-loop motor control is not. That boundary is where the defensible engineering currently sits.

4. "Approve, approve, approve" is the new dangerous default

The Phase Two human did almost nothing but click approve. That is the workflow a lot of agentic coding is quietly drifting toward. It is fine when the agent is wiring up a robodog in a lab. It is less fine when the agent has shell access to production. Frontier Red Team framing exists precisely because this autonomy curve is also a risk curve.

The honest caveats

This is one task, run by one lab, on one robot, with a sample size of essentially a few teams. It is a demonstration, not a benchmark suite, and Anthropic presents it as a red-team capability probe rather than a product claim. The "20x" is against a specific prior-year human team on a specific subset of shared tasks, not a universal multiplier. Treat it as a vivid signal of trajectory, not a number to put in a pitch deck.

Key Takeaways

• Anthropic's Frontier Red Team ran Project Fetch Phase Two: autonomous Claude Opus 4.7 versus last year's best human team (which had Opus 4.1 helping).
• Opus 4.7 solo was more than 18x faster (about 20x) on the shared tasks, and wrote 1,045 lines of mostly-first-try code versus 10,309 for the assisted humans.
• It still failed the actual fetch: it positioned the robot but could not control the real-time motion to move the ball.
• Code-shaped, symbolic engineering is being automated fast; tight continuous physical control is not.
• If you build in robotics or hardware-in-the-loop, the embodied control gap is your current moat.
• The near-zero human role (prompt, then approve) is both the impressive part and the safety warning.

Sources: Anthropic: Project Fetch, Phase Two, Anthropic: Project Fetch, Can Claude train a robot dog? (Phase One), Anthropic on X