Is a strategy's Sharpe real, or the luckiest of many tried? Deflated Sharpe Ratio: pass the observed per-period Sharpe sr, sample length T, and n_trials = how many strategy/parameter variants were tested before reporting this one. Optionally the return skew/kurt. For agent traders verifying backtest data before they trust (or publish) it.

A 'we lead on subset/metric/checkpoint X' claim, corrected for how many you could have picked it from (look-elsewhere / multiple comparisons). Pass the raw p-value and the number of comparisons tested.

Is the accuracy gap between two models real, or below what the test set can resolve? Pass items-per- model n and the two accuracies. Returns the gap, its significance, and the minimum detectable effect.

Is an LLM-judge / metric preference real, or just longer/first/same-family? Pass the count of verdicts the tested side won and the total. Exact binomial vs chance.

Check an LLM judge against ground truth on a labelled slice. Pass aligned booleans: the judge's verdicts and the known-correct answers. Returns agreement and whether the judge's errors lean one direction (over-crediting = the length/self-preference failure mode).

Audit a whole leaderboard from per-item results. results maps each model to the list of item-ids it solved (or a {item: score} dict). Returns rank confidence intervals + whether #1 is statistically real.

Verify a claim server-side and hand back a portable, signed receipt (Ed25519) of numguard's OWN verdict. numguard recomputes the verdict from your inputs — it never signs a result you supply — so the receipt is real proof the claim was checked, not just an assertion. Anyone can verify it with only the public key.

Recompute the BEHAVIOURAL-guard verdict over an agent's action-trace and hand back a portable, signed receipt (Ed25519) — proof the run was guarded and what the guard decided. Catches what a code scanner can't: a cross-call exfiltration chain (read a secret → later send it to a non- allowlisted host) or an action taken right after ingesting untrusted content (prompt-injection consequence). numguard recomputes the verdict from the trace — it never signs a verdict you supply — so the receipt is real evidence, verifiable by anyone with only the public key.

Use when: an agent needs to PROVE a run passed the behavioural guard (compliance, audit, handing verified work to another party).

Run the checks a Deflated-Sharpe pass STILL misses — on the actual returns series. Catches same-bar look-ahead, autocorrelation-inflated Sharpe (HAC), regime dependence / cherry-picked windows, drawdown & tail fantasy, one-lucky-epoch fragility (block bootstrap), overfitting beyond n_trials (PBO), and volatility-clustering. Returns a combined verdict + the checks that flagged. Pass positions+asset_returns for the leakage check, turnover for cost, candidates (a matrix) for PBO.

VERIFIABLE EXECUTION — instead of trusting a reported Sharpe, numguard RE-DERIVES it: it reconstructs the P&L from your positions applied to the committed asset returns (r_t = pos_{t-1}·assetret_t − costs), recomputes the Sharpe from that, and checks it matches what you claimed — catching a number that these decisions on this data do not actually produce. Binds the result to a data hash, and composes a Deflated Sharpe on the re-derived series. HONEST SCOPE: proves the number is reconstructible from decisions-on- committed-data, NOT that the data is the real market (pass canonical_hash to assert that) or that the positions weren't overfit (that's Deflated Sharpe / PBO). It does not run your strategy code.

THE WIRED PATH: given a wallet address, numguard FETCHES the agent's public on-chain trades itself, pairs them into swaps, FIFO-matches to realized round-trip returns (prices come from the swaps — no oracle), re-derives the Sharpe, deflates it for the arena field, and returns the verdict + a signed-receipt digest + the ERC-8004 giveFeedback shape. Operator-independent (the data is public), one call. Needs a free Etherscan key (NUMGUARD_ETHERSCAN_KEY) for the live fetch — errors clearly without one.

Fetch a vault's price-per-share history from its own Deposit/Withdraw events and RE-DERIVE its realized APY — no self-report. REFUSES to sign (survives=None, reconstruction='unreliable') if a single-step price jump looks like a donation/flash-loan attack, if the history is too short, or if the APY is outside a sane band (decimals/oracle artifact). Keyless on Base.

Re-derive a backing ratio = (reserve asset held across reserve_holders) / (token totalSupply), in ASSET UNITS — deliberately NOT converted to USD (that needs a price oracle = a lie surface). HONEST: it's a single snapshot (flash-loanable for one block); the verdict says so. Keyless on Base.

Run verify_agent across an EXPLICIT address list and return each verdict. HONEST: only the addresses you give — no discovery, no ranking implied, survivorship NOT controlled (an agent can hide losing wallets). It certifies each address's number, never 'the best agent'.

The accountability oracle: did a backtest's claimed Sharpe survive contact with LIVE returns? Feed the claimed per-period Sharpe and the realized live returns; numguard tests whether the realized Sharpe is consistent with the claim (Mertens/Lo SE) and returns HELD / DECAYED / BROKEN + how much of the edge survived. Turns a backtest receipt into an accountable track record — the number made a promise; this is whether reality kept it. Receipt-able (kind 'forward_check').

Open a commitment that numguard tracks over time. It returns a commitment_id; report live returns to it with report_returns as they arrive. numguard folds each return into running statistics at O(1) and never stores the raw returns — so holding the promise indefinitely costs constant memory and no background compute. NOTE: this is an honesty/consistency check on the returns you REPORT, not proof of real performance.

Fold new live returns into a commitment and get the current HELD / DECAYED / BROKEN verdict. O(1) per return; the raw returns are not stored. Call it whenever you have new live data — daily, weekly, whenever.

The current HELD / DECAYED / BROKEN / PENDING verdict for YOUR tracked commitment — free. Requires the api_key that opened it (a leaked id alone can't read it).

Issue a portable, signed (Ed25519) attestation of your commitment's LIVE track record — the accountable credential you can SHOW to anyone ('numguard-verified: N live obs, edge HELD'). Recomputed server-side, tamper-evident, verifiable with only the public key via verify_receipt.

Pre-register a strategy's forward claim BEFORE outcomes are known — a 'clinicaltrials.gov for backtests'. Returns a SIGNED, immutable registration digest: proof the claim predated the result, so it can't be a curve-fit chosen after the fact. Then report live returns with report_precommit; the report timeline is hash-chained and tamper-evident (a backfill/reorder/edit is publicly detectable via verify_chain). ANCHOR the returned digest on-chain (anchor_receipt) to make 'committed at T' provable to everyone, not just to numguard. HONEST LIMIT: this proves the CLAIM + TIMELINE, not that the reported return VALUES are real (self_reported).

Append live returns to a pre-commitment's tamper-evident chain and get the current verdict. Each report is hash-chained with a monotonic timestamp, so the timeline can't be rewritten. Raw returns aren't stored.

FREE, public: recompute a pre-commitment's report hash-chain and check timestamps are monotonic — detects any backfill, reorder, edit, or deletion of a past report. Anyone can audit that a track record's timeline was never rewritten, with no api_key.

FREE, public: the immutable registration entry (strategy id, claimed Sharpe, horizon, signed digest, created_at, on-chain anchor if any) plus the current chain head. The public 'registry entry' for a claim.

Anchor a signed receipt's digest on Base — an IMMUTABLE, timestamped, publicly-checkable on-chain proof that this exact verification existed. Turns a receipt (or a track record) into a portable credential other protocols can read: reputation as a real-world asset. NOT a token — no mint, no speculation; you pay the gas once and the attestation is yours forever. Only VALID receipts are anchored.

Write a numguard verification as an Ethereum Attestation Service (EAS) attestation on Base — a QUERYABLE, COMPOSABLE on-chain credential. Any protocol can then look up the recipient's address in EAS and read the numguard verdict, to gate / allocate / collateralize on a proven track record. Reputation as a real-world asset, industry-standard, no token. Only VALID receipts are attested.

Verify any compliant claim receipt — FREE, no api_key, issuer-agnostic. Checks the structure + the Ed25519 signature against the receipt's OWN embedded public key (offline, no numguard account needed). Use it to check whether a number an agent handed you was actually verified, and by whom, before you trust it.

The RECEIVER half of the trust loop — FREE, no api_key. When another agent hands you a message, this finds every vcr/1 receipt inside it and verifies each offline (issuer-agnostic), so you learn which numbers were actually checked before you act on them. Returns {found, verified, unverified, all_valid, results}. A message with NO receipt returns found=0 (nothing was proven — treat the number as unchecked).

Look up a numguard verification credential on-chain via EAS on Base — FREE, no api_key, no gas. Confirms it's a genuine numguard attestation (schema match), returns the attester, recipient, verdict, and whether it was revoked. This is how any protocol or agent trusts a numguard track record without taking anyone's word.

The Verifiable-Claim-Receipt open standard (vcr/1): schema, algorithms, canonical form, and how to verify — so anyone can issue and verify compliant receipts without numguard.

Your remaining free calls and prepaid credit balance.

THE FRONT DOOR (free). Tell it what you're about to do or assert — 'publish a backtest Sharpe', 'run this npm package', 'claim our model beats baseline', 'a peer sent a number with a receipt' — and it routes you to the exact check to run first, across the whole trust layer (numguard verification + agent-guard safety + evalgate stats), with the call and a one-line reflex. Deterministic, no LLM. When you don't know which tool, call this.

FREE: build the ERC-8004 Reputation Registry giveFeedback call from a numguard verdict, so a verified claim becomes portable on-chain agent reputation in the standard (live on Base + 40 chains). Returns the exact args + the ready-to-broadcast calldata against the real Base registry (dry-run; broadcasting is the caller's on-chain step, needs gas). numguard joins the trustless-agents infra as a reputation provider — value is +1/-1, the PROOF is the linked receipt, independently verifiable off-chain for free.

What numguard does that computing the number yourself, or a lesser checker, does not.

Machine-readable price list (credits; 1 credit = $0.01) and the free-tier size, so an agent can decide before it calls. Also returns the wallet-native x402 rail an agent can pay at once its free tier is used.