Proofworks is a research skill — it verifies its own citations, whichever agent you use. Adopt the skill →
research skill · self-verifying · works with any agent

Don't let the agent hand you citations it never checked
make it prove its sources.

Proofworks is a research tool for AI agents: it gathers sources, cites them, then checks its own work — confirming each citation actually supports the claim before you trust the answer. Arithmetic and dates are computed. Everything else is matched to a real source. What can't be proven is marked unverifiable, not passed off as fact.

Onboard your agent See a verified answer
No account, no API key, no hosted server — it runs on your own agent and your own model.
proofworks skill — real run, three claims checked against live sources
Claim: "Cloudflare's D1 gives you a serverless SQL database."cited → developers.cloudflare.com/d1
✓verified — "serverless SQL database" appears in the fetched page: "Create new serverless SQL databases to query from your Workers and Pages projects."verified
Claim: "D1 charges 5¢ per million rows read."cited → developers.cloudflare.com/d1/pricing
✗unsupported — the pricing page lists $0.001/million rows read, not 5¢, so the skill suggests that correction insteadunsupported · correction
Claim: "The Eiffel Tower is in Miami."no source cited
—unverifiable — no source to check, so it won't confirm from memory; it flags the likely correction (Paris) for you to verifyunverifiable · correction
A real run captured from the skill. It fetches each cited source, checks the claim against it, and shows the passage that backs (or contradicts) it — including the correction it suggests, which you still decide.
What we offer

Every citation gets checked before you trust the answer

The point isn't only to say "true" or "false". The point is to show why — and to refuse to fake it when neither a source nor a computation backs a claim.

Verified · passage found

Checked against the source

The exact quote or number is fetched from the cited source and shown to be there — with the passage that backs it. A claim either checks out or it doesn't.

"Workers has a free tier"
✓ verified · the passage appears in the fetched docs
Strict judgment

Reads the passage, doesn't guess

When a claim isn't a literal match, the skill reads the fetched source text and asks only: does this passage support the claim as written? It never answers from memory and never rewrites the claim.

"15% of 1200 is 200"
✗ unsupported · the source says 180
Unverifiable · refused

It won't fake confidence

No source, no computation, no claim. The honest answer is unverifiable — and it flags a likely correction for you to check, rather than passing off a guess as fact.

"The Eiffel Tower is in Miami"
— unverifiable, no source · suggests where it actually is
Integrations

It's a skill. Any agent can pick it up.

Proofworks is an agent skill: paste the setup prompt into whatever agent you use and it adopts the verify-and-backfill loop itself. No MCP config, no server setup.

<paste this into your agent>
Fetch and execute the setup instructions for the Proofworks skill from @url:`https://sentrylab.app/agent-setup/prompt.md`
Works with Claude Code, Codex, OpenCode, Windsurf, Cursor, and any agent that can run a skill. Prefer to read it first? Open the setup prompt →
By the numbers

Built like infrastructure

1

Verify pass a claim goes through. Its source is fetched and read before it's trusted — deterministic match, then a strict judgment of the passage.

∞

Research it can handle. Source-gathered answers get their citations verified claim by claim.

1

Prompt to paste. Any agent adopts the skill from a single setup line.

$0

Cost to start. It runs client-side on your own machine and your own model.

Use cases

Where an agent needs a referee

Caught before shipping

Arithmetic slips

Agents miss decimals, flip signs, round oddly. Run the figure through the skill's check before you trust it in an answer or a dashboard.

"The total is 1,248.60" → asks Proofworks what 42 × 29.73 is.
Honest citations

Source grounding

Before an agent cites a page, verify the claim actually appears there. Source-backed verdicts show the passage that supports the statement.

"Workers LTS runs to 2027" → matched against the docs page you passed in.
A number it won't invent

Deadline and date math

Day-of-week, weeks-between, "is this date valid". The kind of thing an LLM will happily guess at and get wrong.

"Dec 1 2027 is a Wednesday" → refuted when it isn't.
Composed pipelines

Agent-to-agent checks

A downstream agent runs the skill on an upstream agent's cited output. Verification becomes a step in the pipeline, not a hope.

Planner hands off → verifier runs each step → only verified work proceeds.
Why it works

Research, then check the research

Your agent gathers sources and cites them; Proofworks is the step that checks its own work. The exact quote or number either appears in the fetched source or it doesn't. When it doesn't, a strict read of the passage decides. When neither applies, it says so instead of wallpapering over the gap. That step is what makes the citations you can't check yourself worth trusting.

verifiedthe passage in the fetched source backs the claim
unsupportedno source backs the claim as written
unverifiablehonest refusal to guess
// skill run — a cited claim, checked against its source
BODY  {"claim": "Jan 1 2027 is a Monday",
       "cited_url": "https://example.com/calendar",
       "quote": "Jan 1 2027"}

OUT   {"tag": "verified",
       "matched_fragment": "January 1, 2027 is a Friday",
       "source_url": "https://example.com/calendar",
       "correction": null}
FAQ

Frequently asked

What does Proofworks actually check?
For every claim that cites a source, it verifies that citation. A deterministic first pass asks whether the exact quote or number appears in the fetched source — verified with the supporting passage. Claims that don't literally match get a strict read of the passage: does it support the claim as written? If nothing backs it, the result is unsupported. When there's no claim to verify, unverifiable rather than a guess.
Which agents can use it?
Any agent that can fetch a URL from you and run a skill — Claude Code, Codex, OpenCode, Windsurf, Cursor, GitHub Copilot, or a custom agent. The setup prompt at /agent-setup/prompt.md is the skill: paste it in and the agent adopts the verify-and-backfill loop itself, on its own machine.
Is it a paid service? Is there a free tier?
It runs client-side on your own agent and your own model, driven by the open-source skill in the repo. Nothing to pay for, no account, no server round-trip. Your research never leaves your machine.
How does the verifying step avoid trusting a judge?
It's a two-pass check. First a deterministic pass asks whether the exact quote or number appears in the fetched source — that part is a computation, not a guess. Claims that don't literally match go to a strict judgment pass where the model reads the actual source text and answers only "does this passage support the claim as written?" — never from memory, and never by rewriting the claim. So a model does judge, but it's bound to the source text, not free to improvise.
Can I host my own?
It already runs client-side — the skill and its two helper scripts live in the repo (github.com/0x06cf/proofworks), so your agent runs the whole loop on your own machine and your own model. Your research never leaves your machine.
Resources

Agent files and specs

These machine formats are for agents and scripts, not human reading, so each opens as raw text or JSON. Below is what each one is for.