What is a sprint contract in agent harnesses?
A sprint contract is an agreement, negotiated between a generator agent and an evaluator agent before each chunk of work, that lists what will be built and the testable behaviours the evaluator will use to decide it is done.
The term comes from Anthropic's "Harness design for long-running application development" (2026-03-24). The harness had three agents: a planner that turned a one to four sentence prompt into a product spec, a generator that built the app in sprints, and an evaluator that tested the running app like a user and graded each sprint.
The spec was kept high-level on purpose, so the planner would not lock in implementation details early. That left a gap between a user story and something an evaluator could test. The sprint contract fills that gap, one sprint at a time.
How the contract is made
Generator proposes
Before each sprint, the generator writes what it will build and how success will be checked.
Evaluator reviews
The evaluator checks the proposal targets the right work, and the two iterate until both agree.
Written to files
The agents exchange the contract through files, so it survives context limits and can be read by a person.
Specific criteria
Contracts list testable behaviours. In Anthropic's example, one sprint for a game's level editor carried 27 criteria.
Graded against it
The evaluator drives the app with Playwright and fails any sprint that misses a hard threshold, with detailed feedback for the next round.
Why it mattered, and when it went away
Anthropic gives a cost comparison on the same prompt. A solo agent took 20 minutes and $9, and the app's core feature did not work. The full harness took 6 hours and $200, over 20 times the cost, with much better output. The sprint contract was one of the components of that harness.
With a newer model, Anthropic removed the sprint construct altogether: the builder ran coherently for more than two hours without it, and the evaluator moved to a single pass at the end. The post's broader lesson is that every harness component encodes an assumption about what the model cannot yet do, and should be removed when that assumption stops holding.
What it is often confused with
A spec
The spec describes the whole product at a high level. A sprint contract covers one chunk and is written to be tested.
Acceptance criteria
Close in content, but a sprint contract is negotiated by two agents at run time rather than written by a person up front.
"Done when" criteria
OpenAI's term for completion checks written into a task's spec. Same goal, set once at the start rather than renegotiated each sprint.
How Motiontic's engineers apply it
Motiontic's engineers borrow the core move even outside multi-agent setups: before an agent starts a chunk of work, the checks that will grade it are written down and saved alongside the code. Whether a separate evaluator is worth its cost is settled by eval runs, and revisited when the model changes.
Common questions
What is a sprint contract in AI agents?
It is an agreement between the agent that builds and the agent that checks, made before each sprint, on what will be built and which testable behaviours prove it works.
Why not let the generator grade its own work?
Anthropic found agents tend to rate their own output too highly. A separate evaluator holding an agreed contract gives an outside check the generator cannot talk its way past.
Are sprint contracts still needed with stronger models?
Not always. Anthropic dropped sprints with a later model because it stayed coherent for hours without them, while keeping a final evaluator pass for tasks at the edge of the model's ability.
Related
Generator-critic loop
One model drafts, another grades, and the loop runs until the grade passes.
"Done when" criteria
Completion written down as checks before the agent starts, not judged after.
Initializer agent
The one-off first session that sets up everything later agent sessions rely on.
Harness engineering
Designing the environment an agent works in, so its output can be checked and shipped.
AI agent development
Agents that do real work for users, with the evals, traces and guardrails to keep them in production.
Running agents that have to hold up?
Describe the agent, the systems it touches and what it must never get wrong. The first call is with a lab engineer, who will say plainly whether it is ready for production, and whether Motiontic is the right team.