On August 26, Anthropic published an engineering write-up on Warp, detailing how the company keeps its own agents correcting their behavior over time without ever touching the model's weights.
Warp builds an AI terminal and agent development environment. Founded in 2020 by Zach Lloyd, the company has raised $73 million to date. By its own numbers, Warp has 800,000 monthly active developers, and 56% of Fortune 500 companies have used its products. Claude Code has run more than 10 million sessions inside Warp cumulatively, currently exceeding 400,000 sessions a week, with total agent conversations on the platform reaching 40 million.
A three-layer structure
Strip the mechanism down and there are only three pieces.
At the core sits a base skill — a file that spells out domain knowledge and operating rules, such as what a code review should check for and what counts as a blocking issue. In the middle is human feedback: developers' assessments of the agent's output. On the outside is a rewriting agent, which Warp calls the improver skill internally. Its job is singular: periodically gather up the feedback and propose small edits to the base skill.
Lloyd describes the structure this way:
"There's the base domain-specific skill and then there's the improver skill that refines that domain-specific skill. This simplicity is the beauty of this approach."
Skills live as files, built on the Agent Skills API on Claude's platform. That choice has bigger knock-on effects than it sounds. The files can be edited directly by the agent and also checked into Git, so every change the improver proposes shows up as an ordinary code change that goes through the team's own review process. A human can veto it, roll it back, or simply read the diff to see what rule the agent just added for itself. Moving the knowledge into the file system, rather than piling it into a prompt, turns "why did the model change again today" into a traceable commit.
There's a premise here that's easy to miss: the outermost of the three layers is itself a skill file. How the improver reads feedback, decides whether a change is warranted, and how much to change at once — all of that is also written down in a file, and can also be edited by a human. Nothing in the system is a black box; when something goes wrong, you can trace it through two files.
Feedback quality sets the ceiling
Warp's code review agent launched at roughly 80% accuracy, and this loop is what closes the remaining gap. Lloyd's emphasis is on the shape of the feedback: a one-line "this review wasn't good" does nothing, while "detailed reasons why a code review wasn't good" is what actually drives learning.
The catch is that writing detailed reasons takes time, and developers are busy shipping their own work. Warp's fix is to make the feedback entry point as low-friction as possible — in Lloyd's words, "Low friction is what keeps signal flowing." That principle is harder to execute than the three-layer architecture itself: the architecture can be built in a week, but getting a team to keep leaving informative feedback over the long run is a product design problem.
Where this approach runs out
Run the economics of the loop and they're modest. The improver only runs once enough feedback has piled up; each run reads the aggregated feedback plus a skill file of a few hundred to a few thousand tokens, and produces a diff of a few lines. Compared with fine-tuning, the cost is close to negligible — the trade-off is that it can only change explicit rules written into files. It can't touch the model's own judgment or preferences.
So this is less about making the model smarter and more about giving the agent a living operations manual. It suits tasks where the rules are clear, feedback is dense, and right or wrong can be judged: code review, ticket triage, format conversion. Once a task needs the model to change its underlying judgment, the loop hits its limit.
For most teams, that ceiling isn't really a problem. The vast majority of errors agents make in production trace back to rules that were never written down clearly, not to how strong or weak the model is. Writing the rules down clearly used to mean a human rewriting the prompt over and over; now there's a collaborator that does the writing itself, with every change laid out on the review table.
Sources: Anthropic's official blog post on the Warp engineering retrospective, CocoLoop, Warp's publicly disclosed product and funding information; session counts, accuracy figures, and funding amounts are recorded as publicly disclosed.