Get started

Agents shouldn’t grade their own homework.

Agents write code, change infrastructure, and run whole workflows — and the agent doing the work is usually the same one deciding whether the work succeeded.

DidWork is the independent check. Define what success means, gather evidence that the outcome actually happened, and gate the workflow on the verdict.

Get started View docs

Start with DidWork yourself. Build with did.verify() when you’re ready.

Finishing every step isn’t finishing the job

An agent can execute every step it planned and still fail to accomplish what you actually asked.

  • Change 7 of 8 required files
  • Write a migration without running it
  • Create an endpoint that returns the wrong result
  • Pass one test suite while breaking another
  • Deploy successfully while the application stays broken
  • Satisfy the prompt while violating an important constraint

The agent may genuinely believe the job is finished. DidWork separates doing the work from proving the work was done.

WHAT DIDWORK SOLVES

A neutral gate between execution and success

Stop self-verification

The worker shouldn’t decide whether its own work succeeded. DidWork evaluates completion independently from the agent performing the task.

Agent works→DidWork verifies→Workflow continues

Catch incomplete work

Agent failures are often partial, not catastrophic. The code exists. The command ran. The deployment completed. But the intended outcome still didn’t happen. DidWork verifies the result you care about rather than whether an action executed.

Execution is not completion.

Reduce the supervision tax

AI coding tools save hours, then quietly give some of that time back in manual verification: open the diff, run the tests, check the browser, inspect the logs, try the endpoint, make sure nothing was forgotten.

Less babysitting. More building.

Create gates between agents

Multi-agent workflows get dangerous when one agent’s claim of completion automatically triggers the next. DidWork puts explicit verification boundaries between them, so agents collaborate without blindly trusting one another.

Agent A→verify→Agent B→verify→Agent C

Turn failures into useful feedback

Verification doesn’t only stop bad work from moving forward — it tells the system what remains unfinished. A failed verdict can trigger remediation, retry only the missing work, escalate to another agent, or request a human.

Try→verify→repair→verify again

Verify with evidence

Another model saying “looks good” isn’t much better than the original model saying “done.” DidWork is built around observable evidence wherever possible — tests passed, expected files changed, the endpoint returned the required response, database state changed, the deployment is serving the new behavior, the artifact exists. Models reason over that evidence when judgment is necessary.

Evidence first. Model second.

Define what “done” means

Turn important tasks into explicit verification contracts. Success no longer lives inside a prompt or the agent’s interpretation of it — it becomes part of the system. Reusable. Inspectable. Enforceable.

await did.verify({
  task: "implement-login",
  requires: [
    "tests.pass",
    "route.exists",
    "auth.sessionPersists",
    "redirect.matches"
  ]
})

What verification unlocks

Once outcomes are checked independently, the things you couldn’t safely automate become things you can.

More autonomous workflows

The limit on agent autonomy isn’t only intelligence — it’s consequence. When consequential actions are independently verified before the workflow continues, teams can move on from checking every step by hand.

suggest→human checks→approve
act→verify→continue

Better agent performance

Measure agents by completed work instead of confident answers.

  • Which agents complete which tasks reliably
  • Where particular models tend to fail
  • How many retries a workflow needs
  • Which checks fail most often
  • Where humans are still necessary

A record of what happened

A structured history of agent work — a foundation for debugging, auditing, incident investigation, and agent evaluation.

requested→attempted→evidence→verified→retried→completed

Don’t just log what an agent said. Log what the system could prove.

Start where you already work

You don’t need to rebuild your stack. Start by using DidWork alongside the agents you already use.

Claude Code finishes a task.

Check it.

Cursor makes a change.

Verify it.

Your agent says the bug is fixed.

Find out whether it actually is.

Once verification is part of the way you work, add did.verify() to the applications and agent workflows you build.