Auditora runs a contract past a review board of agents — a Scout that reads the chain, an Auditor that proposes findings, an adversarial Challenger that attacks them, and a deterministic Judge — then anchors the surviving verdict to a public registry on Monad, bound to the contract's codehash. This page explains the mechanism, the honesty model, and the onchain layer.
Ask one model “is this contract safe?” and it answers in the same confident voice whether it's certain or guessing. The dangerous misses are the quiet ones — the vulnerability it never mentions, and the plausible-sounding one it invents.
Auditora's answer is not a vote, it's an argument. One agent proposes findings; a second agent, running on a stronger reasoning model, is tasked with breaking them — proving false positives wrong and catching what the first missed. A finding is only trusted once it has survived that attack. Adversarial review catches more than agreement between look-alike models, which can share the same blind spot and be confidently wrong together.
And because a verdict is only useful if others can find and trust it, Auditora doesn't stop at a web report: every audit of a deployed contract is attested on Monad, where anyone can look it up without trusting us.
0x… address on Monad
│
▼ SCOUT read the live chain — owner + type (EOA / multisig / renounced),
│ native funds at risk, proxy → implementation, verified status.
│ (Etherscan V2 + Monad RPC. Proxies are audited at the implementation.)
│
▼ AUDITOR real code + Scout's evidence → proposes candidate findings (JSON)
│
▼ CHALLENGER stronger reasoning model, given the code AND the recon:
│ attacks each finding → upheld / disputed / rejected, and catches misses
│
▼ JUDGE deterministic: status follows from the verdict; posture from status
│
▼ NOTARY keccak256(canonical report) ──► AuditoraRegistry.attest() on MonadThe agents differ by job, not vendor, so the design is honest on any model set. On a single provider a fast model proposes (Auditor) and a reasoning model challenges — a genuine fast-proposes / deep-reasons asymmetry. Each agent returns strict JSON; if one call fails, the run continues and the UI says the board was degraded.
The Challenger is the adversary. For every proposed finding it tries to build a refutation, then rules — and because a wrong rejection would declare a drainable contract safe, it only rejects when the refutation is airtight and defaults to “disputed” under any doubt:
The Judge is deterministic: a finding's status is a pure function of the Challenger's verdict, and the headline posture is computed from those statuses — never from model prose. That is the anti-inflation rail: a model cannot talk its way to “critical” on the strength of confident wording.
When Auditora audits code resolved from a real Monad address, the Notary anchors the verdict to AuditoraRegistry, a small contract on Monad. Each attestation stores:
codehash — the target's EXTCODEHASH at audit time. A verdict can never be carried over to different code: if the contract at that address ever changes, the attestation shows as stale automatically.reportHash — keccak256 of the canonical report JSON. Auditora returns the canonical report to the caller; anyone holding it can re-hash and verify it against the chain.posture + counts — the verdict itself (clean / no-consensus / corroborated, plus confirmed and disputed counts), readable by other contracts and indexers.The registry also has a paid request queue: requestAudit(target) takes a small fee in MON and emits an event; the Auditora operator fulfills open requests and the attestation marks them done. That's the business model, onchain: audits as a public service with pay-per-use pricing.
Known limit, stated plainly: a proxy's own codehash never changes when its implementation is swapped — audit implementation addresses, not proxies. (Scout resolves the implementation automatically for the audit.)
Auditora is a first-pass triage layer, not a replacement for a professional audit and not a safety stamp. Surviving an adversarial challenge is a strong signal, not a proof — models can still share blind spots, so “no confirmed findings” means “nothing survived attack,” never “proven safe.” An attestation records exactly what the board concluded and when — it is not a certificate.
What it does do well: it makes silent misses loud, it knocks down false positives instead of parroting them, and it makes verdicts public and tamper-evident — a contract that was audited before its code quietly changed stops looking audited.
npm install
cp .env.example .env.local # add your gateway key (OpenRouter or DeepSeek)
npm run compile # solc → lib/registry-artifact.json
AUDITORA_SIGNER_KEY=0x… npm run deploy # deploy the registry to Monad testnet
npm run dev # http://localhost:3000With no key set, Auditora runs in mock mode — the full interface works against canned data so you can explore it offline. Add GATEWAY_API_KEY to go live, and AUDITORA_REGISTRY_ADDRESS + AUDITORA_SIGNER_KEY to anchor verdicts on Monad.