How RIGOR works

The two stages

Finished paper

Your results and content are settled. RIGOR checks whether what is there is true, consistent and supported. It does not go looking for a different specification that would give you a nicer answer.

Working paper

The work can still change. RIGOR does the same audit and then proposes the smallest work that would make your claims defensible, ranked by what it costs against what it buys. It also tells you which work not to do.

Two questions, not one

RIGOR asks you how deeply to audit and what to audit. These used to be one menu, and mixing them made the menu lie: a reader choosing "comprehensive" could not tell whether they were buying more areas or more scrutiny of the same area.

You choose why and how deeply. RIGOR discovers which methods need auditing. You do not pick "difference-in-differences" or "clustered standard errors" from a list. The router reads the manuscript and loads the method it actually finds, and the report names every method it loaded.

How deeply: general or detailed

Both depths hold the same standard of truth. Depth changes what RIGOR owes you, never how rigorous it is about what it does check. A general audit is not a sloppier audit of everything, it is a complete audit of less.

RIGOR never quietly lowers the standard for a general audit. What a general audit reports, it verified.

What to audit: one focus, or up to three

A focus is one report, and you may choose up to three, getting one report for each plus a combined document. Full paper is a composition: it audits internal consistency, econometrics and mathematics in one report, and is available because every part it orchestrates can be run. Qualitative validity and Structure and writing are designed but not yet runnable, and are not part of it.

The list above is generated from the audit server's own registry, and a test fails the build if it drifts from it, so it is not a list anybody keeps up by hand. Any focus shown as unavailable is designed and specified but not yet runnable, and is marked so; RIGOR does not substitute a generic pass and call it the same thing.

Coverage follows what you chose. A focused audit runs exactly the modules that focus names: RIGOR does not quietly add a literature pass to a mathematics audit, and does not charge you for one.

Econometrics is six specialists composing one report: the paper's own scientific design is mapped first, then statistical consistency (every reported number recomputed from the paper's own inputs), the specification and estimator, inference, the estimand, causal identification and measurement. Each finding shows the minimal formal check that proves it, and unverified leads are reported apart and never drive the score.

For a paper still in development

When the work can still change, RIGOR does the same audit and then proposes the smallest work that would make the claims defensible, ranked by what it costs against what it buys. It also tells you which work not to do. The same two depths apply: a general development pass finds where the project is weakest, a detailed one adds a staged, costed work program.

Terms you will see in the report

Severity

Fatal, major, moderate, minor. Fatal means a central claim does not stand as written. Minor still gets a full repair plan, because that is where unswept residue accumulates.

Root cause

One upstream error usually produces several visible symptoms. RIGOR records the cause once and lists what depends on it, instead of giving you six findings that are the same finding.

Scope reduction

Narrowing a claim instead of repairing the defect. RIGOR refuses this while a proportionate repair exists, and when a claim genuinely must be narrowed, it states exactly what scientific content is lost.

Implementation ready

A finding is not finished when it is described. It is finished when you have the canonical fix, every other place the same cause reaches, a search you can run to find the rest, a list of what must not change, and a test that tells you the change is fully applied.

Changeset miss

When a later audit finds residue that an earlier repair plan should have swept. RIGOR counts this against itself, not against you.

How the audit closed

Every report ends in one of three states, and the state is on the cover. Audit complete means every area RIGOR owed you under your chosen depth was reviewed and verified. Audit complete with limited coverage means a general audit finished what it owed and left other areas unreviewed, and the report names them. Audit incomplete means it could not reach closure, which is what a detailed audit reports whenever any applicable area was left unreviewed. RIGOR would rather say it did not finish than present a clean bill of health it did not earn.

Finding identifiers, such as LIT-001

The letter group names the specialist the finding came from: LIT for literature, MAT for mathematics, STA for statistical consistency, INF for inference, CAU for causal identification, IDE for the estimand, MEA for measurement, CON for consistency, THE for theory against evidence. The number is the order in which it was found, so LIT-001 is the same problem across revisions.

The score, such as 4 out of 10

A function of the findings and nothing else, so the same ledger always gives the same number. Severity sets a ceiling nothing can lift: an open fatal finding caps the score at 3, five open major findings cap it at 4. When the audit did not reach closure the number is shown as at most, because further findings can lower it and cannot raise it.

A full-paper audit carries one overall rating. A focused audit does not: it reports a score for the area it examined, and nothing else. Grading a whole paper on a reading of its literature section would be a number RIGOR has no standing to give.

Rounds and search strategies

Each audit records the strategies it searched with, and the report names them. A general audit owes one independent check on every major finding; a detailed audit owes two, by materially different strategies. Where the record shows fewer, the report says so rather than claiming closure.

Submission readiness

One verdict about the manuscript, at the top of every report: ready for submission, ready with minor revisions, not ready for submission, or readiness not assessed.

The last one is not a failure. It is what RIGOR says when nothing blocking was found but it did not read enough of the paper to clear it — a literature-only audit cannot certify econometrics it never opened. The reverse is not symmetric, and deliberately so: one established fatal or major finding is enough to say a paper is not ready, however little of it was read, because finding a blocker settles the question on its own. So a focused audit can tell you no, and only a complete one can tell you yes.

The model proposes this verdict and the ledger decides it. A ready verdict is refused while a fatal or major finding is open, whatever the model wrote.

What the progress panel is telling you

An audit of a full paper takes several minutes, and most of that time the model is reading without producing output. The panel is built so that silence never looks like failure, and so that nothing on it is a guess.

The map

Each node is a stage the server actually scheduled. It changes state when work finishes, never with the clock: it can sit still for minutes and then settle several nodes at once, because that is when the work actually finished.

The clock

Real elapsed time, nothing more.

The tally

Rounds, findings opened, findings merged under a root cause, findings cleared on verification, and tokens spent, all counted by RIGOR from what it received.

The lines that scroll past

Short descriptions of what is being looked at. Commands are never shown.

If the panel stops

The audit runs on the RIGOR server handling your session: your own machine when you run RIGOR locally, our host when you use the site. If that process stops, the audit stops with it and your manuscript is deleted. The page says so rather than leaving a frozen timer.

When an audit does not finish

A provider exiting successfully is not the same as an audit succeeding. RIGOR reports an audit complete only when the provider finished, an audit record exists, it parses, it validates, its ledgers load and the report builds. If any of those fails you are told which one, and no report is invented. Your manuscript is deleted either way, and a sanitised record of what the provider produced is kept so the failure can be diagnosed.

If you asked to be emailed

The address is used once and discarded; it never reaches the model, the audit or the report. You get a message whichever way the run ended: a finished report, an audit that did not reach closure, or a run that failed, each saying which. The download link in it works for 72 hours, and on the hosted site the report is deleted after that, so save the PDF. If mail is not configured or the provider is down, the audit is untouched and the report is still on the site.

How it runs

Your own API key

RIGOR connects directly to Anthropic or OpenAI with your own API key, so the provider bills the usage directly and RIGOR charges no platform fee. The key is held in memory by the RIGOR process running your audit: on your own machine when you run RIGOR locally, and on the RIGOR server when you use the hosted site, for this session only. It is never written to disk, never stored in your browser, and never appears in the audit record or the report. Forget key removes it immediately, and closing the session removes it anyway.

A RIGOR-run audit

If you prefer not to use your own API key, RIGOR supplies the provider access and pays the AI provider itself. You pay a fixed price for the audit through Stripe, which processes the payment; RIGOR does not receive or store your full card details, and you supply no AI API key at all. Each credit includes a stated amount of AI compute. An audit uses only the compute it actually needs, and any unused compute remains available on that credit for thirty days.

RIGOR-run audits currently use Anthropic's Claude models through their commercial API. You are paying RIGOR for the audit, not purchasing access to Anthropic's API. The provider and model that will read your manuscript are shown before the audit begins.

Buying an audit does not create an account here. There is no registration and no password on this site in either path.

The quote: what your paper needs

RIGOR reads your manuscript first and recommends after. The preflight detects what the paper is — finished or in progress, empirical or theoretical or both, econometrics-heavy, carrying a formal model, reporting families of specifications — and from that derives which audit areas apply and which checks each one owes. Only then does it show you a recommended audit, and for each model the expected API usage and a recommended run limit, computed for your paper from the provider's real prices. Two papers of the same length can quote differently, for scientific reasons.

The arithmetic behind the numbers, for the curious. Each applicable check j has a minimum viable authorisation V_j(paper, model) — enough to send its request at full output, priced worst-case. The technical minimum is the sum B_min = Σ_j I_j·V_j over the checks that apply (I_j ∈ {0,1}); when the preflight cannot rule a check out, it stays in. The recommended run limit is the smallest offered amount at or above max(B_min, the product's starting floor), and expected usage is the separate, lower figure a typical run actually settles at with prompt caching. An audit whose limit cannot fund every applicable check is refused before it starts — RIGOR never sells a partial audit — and once admitted, running out of budget is no longer a reason a report can fail to appear.

If the model you picked cannot complete this paper within your limit — a long manuscript on an expensive model is the usual reason — Start is disabled and you are shown the limit it needs and which cheaper models would fit. RIGOR never quietly switches your model and never charges for a run that cannot do the work.

There is no thoroughness dial. Whatever RIGOR checks, it checks at full strength: it keeps looking from different angles and verifying its own findings until it reaches its closure standard or states exactly what it could not finish. General and detailed change how much RIGOR owes you — how many areas, how many independent checks, whether minor findings are reported — and never how rigorous it is about any one of them. A general audit is a complete audit of less, not a looser audit of everything.

Choosing up to three reports

RIGOR reads the manuscript once and keeps one issue ledger. Asking for three reports adds the extra analysis each one needs, not three separate audits.

Pricing

With your own API key, RIGOR itself is free. You only pay your AI provider for the tokens you use. Specialized reports such as mathematics, econometrics, statistics, consistency, and theory and evidence start with a $5 API budget. Full audits start at $10 because they combine several specialized audits into a single report.

The exact budget depends on your paper and the model you choose. RIGOR analyzes your manuscript first and recommends the amount needed to complete the report; longer or more complex papers, and more expensive models such as Fable, may require a higher budget. The recommended amount is a run limit, not a price — your provider bills only what the audit actually uses, which is usually well below it.

With a RIGOR-run audit, you do not need an API key. You pay a fixed price through Stripe and RIGOR supplies and pays for the model usage; each package states the amount of usage it includes, the audit consumes only what it needs, and the unused part stays on the credit for thirty days. Tax, where it applies, is shown at checkout.

Where your manuscript goes

RIGOR sends your manuscript only to the RIGOR service processing this audit and to the AI provider performing it. The service copies it into a private working folder for the length of the run and deletes that copy when the run ends. The provider reads it — under your own account when you bring a key, under RIGOR's when you buy a RIGOR-run audit — because a model has to read the paper to audit it. RIGOR shares it with no one else.

RIGOR itself does not keep your manuscript and does not use it for anything besides this audit — not training, not evaluation, not a sample. What the AI provider does with API traffic is governed by that provider's own terms — your provider's when you bring a key, Anthropic's when you buy a RIGOR-run audit.

This page used to say the file never passed through a RIGOR server. That was true when RIGOR only ran on your own machine, where the server and the computer are the same thing, and it stopped being true the moment it was hosted. We would rather correct it than let a sentence written for one deployment keep making a promise the other cannot keep.

We would rather say that plainly than imply an audit can happen without a model reading your work.

What RIGOR does not claim

• It does not replace peer review.
• It does not guarantee acceptance or publication.
• It does not catch every error, and it will not pretend an audit is complete when its own closure standard is not met.
• It does not grade your paper. The rating it shows is a mechanical function of the findings and their severities, so the same ledger always gives the same number and severity sets a ceiling nothing can lift: it is a summary of what the audit found, not a judgement of the paper's worth. Scientific quality is not one number, which is why the findings, coverage and verification state are the report, and the rating only points at them.