Anthropic engineer with a $950K salary says agents keep crashing because no one builds a harness

A tweet shows the salary range for an Anthropic engineer: $350,000 to $950,000. According to him, the valuable skill isn't tuning models—it's building a harness.

Here's how he put it: 99% of people are still manually assembling multi-agent systems and then wondering why they keep crashing. The system he built runs loops, calls tools in a sandbox, and turns yesterday's logs into today's new skills. With the same model, agent reliability is 10x higher, and while he sleeps, it keeps getting better on its own.

The tweet lays out a path: Opus 5.5 → Agents → Harnesses → Loops → Graphs. Then comes a short workshop: build one from scratch in five steps.

First, let's clarify what a harness is. You can think of it as a runtime framework wrapped around the model that manages three things: how the loop runs, what context is provided, and where tools run. The model itself only handles reasoning; the rest of the dirty work is caught by this layer.

The five steps are roughly divided like this.

Step one: use a harness to uniformly manage the loop, context, and sandbox. The loop is the rhythm of the agent repeatedly executing actions, context is what information is fed to the model each round, and the sandbox is the execution boundary for tools. If these three aren't managed within one framework, the system starts fighting itself as soon as it gets complex.

Step two: separate the brain from the tools. The model only makes decisions, and tools are called through independent interfaces. The data cited in the tweet is that this can make the first token 60% faster. For interactive products, first-token speed basically equals the user's first impression.

Step three: the agent runs server-side and recovers from crashes via logs. The key is that logs must be recorded to the point where they can be replayed, not just a few lines of error messages.

Step four: catch failures with retries and replay instead of starting over. This is where a lot of waste in agent systems comes from: one tool call times out, the entire task chain reruns, and both time and tokens are burned.

Step five: turn historical execution logs into new memory so the system is smarter next time. Anthropic calls this process dreaming. The name is a bit romantic, but what it does is quite engineering-oriented: taking past execution traces and filtering, compressing, and feeding them back in.

At the end of the tweet, he adds that most developers would spend weeks manually building these things, and this workshop offers a faster path.

There are two kinds of voices in the comments.

One is from user Nathan Handyman: 99% of workshop posts start with a salary range; at least this one talks about the real stuff—harnesses and crash recovery—so it's worth stealing. That complaint is pretty accurate. The salary numbers are the hook; the substance is in the five steps that follow.

Another is from user Chuckie, in a less polite tone, roughly saying that this so-called dreaming is very similar to what he has been doing all along, and asking whether he should take the files from his computer and show them to the whole world. This one provides no evidence, so it can only serve as a reminder: the concept of dreaming isn't new in engineering. Log feeding, experience distillation—people have done these before. Anthropic packaged it into a productized workflow.

Back to that salary number. Putting the $350,000 to $950,000 range at the start of the tweet really does help it spread, but it also makes it easy to miss the point. The point isn't how much this person makes; it's that he broke the agent reliability problem into five layers of actionable engineering structure. Model capabilities are still rising, but in the short term, the gap in system stability under the same model comes more from this harness layer than from switching to a stronger model.

The original tweet link is here.