Warp builds self-improving agents on Claude

What happened

The file is very long (mostly HTML/CSS). Let me search for the actual article text content. I now have all the factual content I need from the article. Let me write the article.

Warp, the AI-powered terminal and agentic development environment founded in 2020 by Zach Lloyd, published a case study on August 26, 2026, explaining how its engineering team built a self-improvement loop for its AI agents using Anthropic's Claude Platform. The technique evolved from a real frustration: an internal code review agent was making unhelpful comments, and manual prompt rewrites were not scaling. Warp's solution was a two-skill architecture where human feedback accumulated over time is automatically woven back into the agent's instructions after each cycle.

This piece walks through the mechanism behind Warp's self-improving agent pattern, explains why it is structured the way it is, and identifies what teams building similar systems on the Claude Platform should verify before deploying it. Developers working in agentic environments who use GitHub Actions, run code review agents, or are exploring the Claude Platform's Agent Skills feature will find the most relevant material here.

How it works

Warp built its code review agent on top of the Claude Platform and initially tried two stopgap fixes when engineers complained about low-quality output: manually rewriting the prompt after observing failures, and improving context files like AGENTS.md. Both helped at the margins but did not scale. The root cause, the team concluded, was that feedback given to an agent during a session disappears when that session ends, stripping critical context from the agentic loop entirely.

The company's response was a two-skill, human-in-the-loop architecture it now calls a self-improving agent loop. Warp runs this pattern across its entire open-source repository, with separate spec-writing, review, and triage agents each carrying their own independent improvement loop. The company describes the pattern as general enough that any agent handling a recurring task can benefit from it if the loop is built in from the start.

The architecture pairs two Claude Agent Skills — file-based encodings of knowledge that keep instructions out of the raw prompt. The inner, or base, skill holds the functional domain knowledge for the task. When a pull request opens, for example, Warp's code agent executes using that base skill and its context to produce a review. Human feedback on that output is then collected wherever the work is already happening — a comment directly on the PR — so no extra submission step is required.

Why it matters

The outer, or improver, skill functions as a scheduled observer agent rather than a per-task one. It runs on a schedule inside Oz, Warp's internal agent orchestration platform, authenticating to GitHub, pulling recent issues carrying feedback via a bundled Python script, and summarizing that feedback into a JSON file. The improver agent then proposes the smallest edit that captures the signals, opens a PR against the inner skill file, and routes that PR through the normal code-review workflow. A human reviews, approves, and merges, and the next run of the base skill inherits the new knowledge.

The key insight driving the design is that skills are plain files, which means agents are extremely good at updating them and those updates flow naturally through pull request workflows that engineering teams already use. This keeps a person in control of what actually changes while removing the overhead of manual prompt engineering from individual contributors. Because the improver skill is largely domain-agnostic — the observer logic for a code review agent is structurally similar to the observer logic for a triage agent — the pattern is reusable across an entire engineering organization rather than being rebuilt per use case.

Who is affected

Warp's results at scale illustrate both the ceiling and the responsibility. The company has 800,000 monthly developers building on Warp, 56 percent of the Fortune 500 using the product, 40 million total Warp Agent conversations, and 10 million Claude Code sessions run inside Warp to date, with more than 400,000 per week. Managing thousands of code reviews across hundreds of contributors is the environment in which the loop was stress-tested, and the team's candid guidance — assume feedback will sometimes be wrong, filter whose input counts, and keep a human in the loop at the filtering or final-review stage — reflects what running the system in production actually taught them.

The most directly affected group is the roughly 800,000 developers already on Warp who interact with its agents for code review, issue triage, and spec writing. For them, the self-improvement loop means agents running on their repositories will degrade less over time and incorporate team-specific conventions — variable naming rules, labeling logic, review standards — without requiring those conventions to be manually encoded upfront. Warp's guidance specifically warns against opening feedback to everyone indiscriminately, suggesting that for unverifiable domains, feedback should be restricted to domain experts rather than the full contributor pool.

Teams building their own agents on the Claude Platform are a second affected group. Warp open-sourced its issue triage agent at github.com/warpdotdev/warp-agents-demo-github-issue-triage as a reference implementation of the pattern. Builders should verify that their base skill files stay small and use progressive disclosure — referencing resource files and scripts rather than dumping everything into context — and that their improver skill includes enough sanity-checking logic to handle noisy or incorrect feedback from reviewers before it reaches a proposed skill edit.

What to watch next

Warp has $73 million raised and a growing roster of agent types running the self-improvement loop across its open-source repository. The natural next stress test for the pattern is whether the templated base loop holds up as the number of agents scales toward the hundreds — at that point, Warp's own guidance suggests that a handful of improver agents should share a templated structure rather than each owning a fully independent loop. Whether the PR-based approval workflow remains practical at that volume, or whether a more automated gating mechanism is needed, is the architectural question left open.

On the platform side, Anthropic published a companion webinar to the case study where Warp demonstrates the loop live. Builders evaluating the approach should confirm which global metrics — time to merge, contributor count, cost per review — they plan to track and feed back into the improver agents, since Warp's team explicitly recommends measuring system-wide improvement through those existing human-legible signals rather than relying solely on per-task output quality to know whether the loop is working.