s2ar.dev

Evidence an agent can hand on.

Ship what your agent wrote with proof it holds. Check an answer against its source, diff two screenshots, certify a compressed image, score a poem against its form, read one function from a repository. Each call returns the evidence and a signed record anyone can verify free. No model stands behind a witness. A call that fails costs nothing.

Try ten calls a day on every tool with no account. Sign in with an email and start with $1.

an agent's day · 2026-10-11 04:56 UTC · every line from the run, re-derived before it was written
1 Read the function, not the file
$ curl -s -X POST 'https://api.s2ar.dev/v1/sym/read' \
→ HTTP 200 · 216 ms · $0.005 · tokens_est 565
2 Refuse to ship the summary unasserted
$ curl -s -X POST 'https://api.s2ar.dev/v1/assert' \
→ HTTP 200 · 110 ms · $0.005 · PARTIAL · passed 2 · checks 3 · record 3754515b7150…
3 Certify the screenshot before sending it
$ curl -s -X GET 'https://api.s2ar.dev/v1/certify?image_url=https%3A%2F%2Fs2ar.dev%2Fexamples%2Fmedia%2Finvoice.png&probe=ocr' \
→ HTTP 200 · 4321 ms · $0.01 · PASS · record 924aed0a44f0…
4 Verify the assertion record, free
$ curl -s -X GET 'https://api.s2ar.dev/v1/verify/3754515b7150255bc42ac96cf7df751f5c37a522f26ced50442abe734673ba9e'
→ HTTP 200 · 200 ms · PARTIAL · found True · seal_ok True
5 Change one field; watch the seal fail
$ curl -s -X POST 'https://api.s2ar.dev/v1/verify' \
→ HTTP 200 · 93 ms · PARTIAL (tampered copy) · seal_ok False
6 Read the issuer's signed day
$ curl -s -X GET 'https://api.s2ar.dev/.well-known/proceedings.json'
→ HTTP 200 · 91 ms · HTTP 200
6 calls · 3 records verified · $0.02 list · 5,032 ms · run 2026-10-11 04:56 UTC █

Read the run behind every line → · Run the assertion yourself →

0 ▼29 ◆ / 100 ▼520 ◆
paid calls / calls delivered in the latest signed edition of the proceedings
0 ±0 ◆
paid calls that failed and were charged — the refund rule, measured every day
100 ▼523 ◆
metered calls in that edition, the operator's own included (the series)
$0.005
an assertion with a signed record, a graded text, one function's source, an inspection; a repo map or a certified image $0.01
The gallery · the tools, the session, the pixels, the game

See it run.

Open a card. A worked example re-derived on every publish, a clip from the engine the certify witnesses were calibrated on, the game the agent plays. Each caption says what was measured.

The quote is the contract

Ask any route with no key. Read the price, the rails and how to pay before you spend a cent.

One body tells your agent what the call costs, which rails settle it today, what is free, and where the rules live. Nothing moves until the answer exists.

curl -s -X GET 'https://api.s2ar.dev/x402/v1/assert?text=%7B%22a%22%3A1%7D&checks=%5B%7B%22check%22%3A%22json_valid%22%7D%5D'

→ HTTP 402 · 130 ms · list price $0.005

{
  "price_usd": 0.005,
  "rails": [
    "x402",
    "credits"
  ],
  "how_to_pay": "Pay per call with USDC on Base over x402 (no key: sign the 402's accepts[0], resend with PAYMENT-SIGNATURE); or buy a $5 pack by card and send Authorization:…",
  "free.per_day_keyless": 10,
  "free.signup_grant_usd": 1.0,
  "free.signup_url": "https://api.s2ar.dev/login",
  "credits_card.packs": {
    "5": "https://buy.stripe.com/dRm6oGeik0240Zr7q9dIA00",
    "25": "https://buy.stripe.com/bJe6oGfmo6qsdMd6m5dIA01",
    "100": "https://buy.stripe.com/4gM8wOeikcOQ4bD9yhdIA02"
  },
  "credits_mpp.url": "https://api.s2ar.dev/v1/credits/buy",
  "refund_rule": "a paid call that is not delivered is credited automatically and counted in the proceedings"
}
Six tools · one curl each · a real response under every one

Check the answer. Diff the frames. Certify the image. Score the form. Read the symbol. Inspect the endpoint.

assert · an agent's output, checked

Prove the quotation is in the source before the JSON ships.

Hand it the output and the source. It checks the schema, the terms, the lengths, the numbers, the citations, every quoted span against the source and every URL against your domains, or a named rubric. Each check is a pure function of the inputs; the verdict names where it failed; the record keeps hashes, never your text. GET /v1/assert/checks lists them, free.

curl -s -X POST 'https://api.s2ar.dev/v1/assert' \
  -H "Authorization: Bearer $S2AR_KEY" \
  -H 'content-type: application/json' \
  -d '{"text": "{\"claim\": \"ripgrep ignores --glob when a file is given on the command line\", \"quote\": \"the glob given later in the command line takes precedence\"}", "source": "Glob patterns can be used to include or exclude files or directories. Precedence: if multiple globs match a file path, the glob given later in the command line takes precedence.", "checks": [{"check": "json_valid"}, {"check": "required_terms", "terms": ["ripgrep", "--glob"]}, {"check": "quotes_in_source", "min_words": 4, "path": "quote"}]}'

→ HTTP 200 · 105 ms · list price $0.005 · record deb43b0d2add…

{
  "verdict": "pass",
  "passed": 3,
  "checks": 3,
  "results.0.check": "json_valid",
  "results.0.ok": true,
  "results.1.check": "required_terms",
  "results.1.ok": true,
  "results.2.check": "quotes_in_source",
  "results.2.ok": true,
  "results.2.evidence.quotes": 1,
  "record_sha256": "deb43b0d2add0da7ec8c43353132b4bfd4712d90c971e090fb07e6331c648b0b",
  "charged_usd": 0.0
}
inspect · an x402 endpoint, probed

Know what an endpoint declares before your wallet pays it.

Probe it once, the way a wallet or a directory does: the 402, the accepts, the price, the Bazaar extension, the declared method, Coinbase's validator. Eleven checks, a signed record. We probe the market's top hundred every day: the weather.

curl -s -X POST 'https://api.s2ar.dev/v1/x402/inspect' \
  -H "Authorization: Bearer $S2AR_KEY" \
  -H 'content-type: application/json' \
  -d '{"resource": "https://api.s2ar.dev/x402/v1/assert", "method": "GET"}'

→ HTTP 200 · 496 ms · list price $0.005 · record a2b099cddde1…

{
  "verdict": "pass",
  "passed": 11,
  "checks": 11,
  "summary.price_usd": 0.005,
  "summary.networks": [
    "base"
  ],
  "summary.declared_method": "GET",
  "record_sha256": "a2b099cddde1ee3304aadcc6c5e567a341381eca1f9c802242a445fd77a66b89",
  "charged_usd": 0.0
}
sym · code from any public repo

Read the function, not the 7,700-line file.

Map a repository by imports, skim a file's skeleton, pull one symbol's source, search by name or by meaning. Ten languages, tree-sitter, a receipt on every answer. /v1/sym/map $0.01 · /ls /read /find $0.005 · /where $0.01. Free and local too: cargo install starlab-sym.

curl -s -X POST 'https://api.s2ar.dev/v1/sym/read' \
  -H "Authorization: Bearer $S2AR_KEY" \
  -H 'content-type: application/json' \
  -d '{"repo": "BurntSushi/ripgrep", "ref": "14.1.1", "file": "crates/core/flags/defs.rs", "symbol": "Glob as Flag"}'

→ HTTP 200 · 190 ms · list price $0.005 · receipt sha256:598d5e19ec2b…

{
  "tokens_est": 565,
  "receipt.evidence_hash": "sha256:598d5e19ec2bace68778add369e74f054ca7dc43c2583e0e1e0c4cbefa58a832",
  "charged_usd": 0.0
}
impl Glob as Flag (crates/core/flags/defs.rs, lines 2459-2512)
 2459	impl Flag for Glob {
 2460	    fn is_switch(&self) -> bool {
 2461	        false
 2462	    }
 2463	    fn name_short(&self) -> Option<u8> {
 2464	        Some(b'g')
 2465	    }
 2466	    fn name_long(&self) -> &'static str {
 2467	        "glob"
… 45 more lines
score · a text against a form

Grade the haiku by its syllables, not by opinion.

Name the form and send the text. Meter comes from a versioned dictionary, then rhyme, then lines, then the gates: an exact line count, a content floor, no credit for identical end words. Same text, same answer, every time; each gate names its evidence; the answer is a signed record. GET /v1/score/forms publishes the forms and the policy, free.

curl -s -X POST 'https://api.s2ar.dev/v1/score' \
  -H "Authorization: Bearer $S2AR_KEY" \
  -H 'content-type: application/json' \
  -d '{"form": "haiku", "text": "An old silent pond\nA frog jumps into the pond—\nSplash! Silence again."}'

→ HTTP 200 · 112 ms · list price $0.005 · record 8df2a8705a89…

{
  "accepted": true,
  "composite": 1.0,
  "gates.0.gate": "line_count",
  "gates.0.ok": true,
  "gates.0.evidence": {
    "got": 3,
    "want": 3
  },
  "gates.1.gate": "content",
  "gates.1.ok": true,
  "record.outcome": "pass",
  "record_sha256": "8df2a8705a89d7f8b0d855deb31c26b484978f73d8832809285a3677c8a4baa8",
  "charged_usd": 0.0
}
certify · compress, then prove

Shrink the screenshot. Prove the model still reads it.

Send the image. Get back the smallest version a vision model reads the same way, measured by a deterministic witness and sealed per model. GET /v1/verify/{sha} re-checks the record free, forever. The calibrations behind the band: the lab.

curl -s -X GET 'https://api.s2ar.dev/v1/certify?image_url=https%3A%2F%2Fs2ar.dev%2Fexamples%2Fmedia%2Finvoice.png&probe=ocr' \
  -H "Authorization: Bearer $S2AR_KEY"

→ HTTP 200 · 3914 ms · list price $0.01 · record 924aed0a44f0…

{
  "outcome": "pass",
  "verdict": "isomorphic",
  "witnesses.0.name": "ocr",
  "payload.tokens.anthropic": {
    "provider": "anthropic",
    "before": 800,
    "after": 220,
    "saved": 580,
    "ratio": 0.725
  },
  "payload.fidelity.drift": 0.0,
  "payload.fidelity.tolerance": 0.05,
  "subject.1.w": 524,
  "subject.1.h": 314,
  "subject.1.bytes": 5966,
  "record_sha256": "924aed0a44f0e6754350a2cb7e02c8d640dbfd01057843172ea77259aa31df00",
  "charged_usd": 0.0
}
diff · two screenshots, measured

Diff the golden frame against today's. Find what changed.

Send two images. Three deterministic witnesses and no model: a luma difference hash for structure, an 8×8 colour signature for the palette regression a luma hash is blind to, the change in gradient energy for texture, each against a threshold you set. The record names both images by hash, never by pixels. The frames here are a StarLab render and the same render with red and blue swapped.

curl -s -X GET 'https://api.s2ar.dev/v1/diff?a=https%3A%2F%2Fs2ar.dev%2Fexamples%2Fmedia%2Fscene.png&b=https%3A%2F%2Fs2ar.dev%2Fexamples%2Fmedia%2Fscene-rb.png' \
  -H "Authorization: Bearer $S2AR_KEY"

→ HTTP 200 · 633 ms · list price $0.005 · record 74318bd1337c…

{
  "verdict": "regression",
  "outcome": "fail",
  "passed": 2,
  "checks": 3,
  "regressed": [
    "color_sig"
  ],
  "distances": {
    "dhash": 0.0625,
    "color_sig": 0.060417,
    "grad": 0.041722
  },
  "a.w": 729,
  "a.h": 381,
  "record_sha256": "74318bd1337cee42e3a8dd57086ea1bbdadab186d802bcec5bfd681a59d153ea",
  "charged_usd": 0.0
}

Call any route with GET and query parameters or POST and a JSON body; each has an /x402/v1/… mirror that answers the 402 first. Make ten keyless calls a day on every route (three on certify). Use it over MCP at https://api.s2ar.dev/mcp, or in Claude Code: claude plugin marketplace add https://github.com/codylwalker/sym then claude plugin install s2ar@starlab (setup →).

From your tools · no key to start

Call it from curl, Claude Code, Codex or any MCP client. Add a key when you want one.

Every line below runs as written, with no account: ten calls a day on each tool. Add Authorization: Bearer <key> when you have a key and the same calls run on your credits.

curl · any route by GET

One URL, one verdict

curl 'https://api.s2ar.dev/v1/diff?a=https://s2ar.dev/examples/media/scene.png&b=https://s2ar.dev/examples/media/scene-rb.png'

Answers verdict: regression, the three distances and a record_sha256; verify it free at /v1/verify/<sha>. Every route by GET →

Claude Code · one line

Eleven tools in your coding agent

claude mcp add s2ar --transport http https://api.s2ar.dev/mcp

Or install the plugin, which adds the skills that say when to assert and when to inspect: claude plugin marketplace add https://github.com/codylwalker/sym then claude plugin install s2ar@starlab. A key goes in --header "Authorization: Bearer …" or the plugin's settings. Setup →

Codex · two lines of config

~/.codex/config.toml

[mcp_servers.s2ar]
url = "https://api.s2ar.dev/mcp"

Add http_headers = { Authorization = "Bearer …" } for a key. Any other MCP client: streamable HTTP, POST https://api.s2ar.dev/mcp.

Claude · the connector

No install at all

In Claude's settings add a custom connector with the URL https://api.s2ar.dev/mcp/directory and no sign-in: ten read-only tools, the same free calls, no payment path inside a tool. How →

Pricing

Cents per call. Nothing for a call that fails.

route per call what free, keyless
/v1/assert $0.005 Assert an agent’s output 10 a day
/v1/diff $0.005 Diff two screenshots 10 a day
/v1/score $0.005 Grade a text against a form 10 a day
/v1/sym/find $0.005 Code search by name in a GitHub repo 10 a day
/v1/sym/ls $0.005 File skeleton from a GitHub repo 10 a day
/v1/sym/read $0.005 Function source from a GitHub repo 10 a day
/v1/x402/inspect $0.005 Inspect an x402 endpoint 10 a day
/v1/certify $0.010 Compress an image and verify a vision model still reads it 3 a day
/v1/sym/map $0.010 GitHub repo map 10 a day
/v1/sym/where $0.010 Code search by meaning in a GitHub repo 10 a day
/v1/env/reset $0.020 Open an episode of a deterministic environment (baba, sokoban); step it free; the sealed, signed episode. GET ?env=baba 10 a day
/v1/extract_text $0.020 Extract the text from an image 10 a day
/v1/audit $2.000 Audit a reward for gaming: degenerate probes, invariance, soundness, a seeded exploit search; a graded signed record. POST 10 a day

Sign in with an email and start with $1. No subscription, no seat, no minimum. Money moves only after the answer exists; every paid answer carries a receipt (an evidence hash of the answer, the cost, the determinism of the endpoint); verdicts are signed Assay records. The issuer signs its own day — calls paid, delivered and credited — at the proceedings, under the charter: no placement for sale, no different verdict for money, nothing kept about a caller.

Get a key

Four ways in. One ledger for every tool.

Pay the call, or hold a key with credits. Nothing else is asked of you.

A card pack · no account

$5 · $25 · $100

Buy a pack in the browser: $5 · $25 · $100. The key is shown once after payment, then goes in Authorization: Bearer. Credits never expire; a failed call is credited back.

An email · $1 to start

Sign in →

Get a magic link, a key, and $1 of credits on the first sign-in, about two hundred assertions. The account is the key: no password, no profile, nothing kept beyond the balance.

Per call · no account

USDC on Base, over x402

Sign the 402 that names the amount and the payee, resend with PAYMENT-SIGNATURE, get the answer. No key, no account, nothing kept but a salted count. The walkthrough →

An agent wallet

Stripe's Machine Payments Protocol

Send a wallet credential to POST https://api.s2ar.dev/v1/credits/buy; it buys a pack and returns a key in the same response. Over MCP the buy_credits tool does the same.

The research, deeper

Measured, not argued.

Read the lab: certify's calibrations replayed, the sealed record, why a witness and not pixel error, the per-model technique, the savings by model. The certificates page follows the live bands. The agent markets: a daily snapshot of where agents pay. The proceedings as a series. Token economics: a call against a session. The whitepaper · the preprint · the simulation ladder · the assay audits.

The charter · today's proceedings, signed · privacy · terms · operated by s2ar (Cody Lee Walker, Canada) · cody@s2ar.dev