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-30 12:49 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 · 203 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 · 162 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 · 4522 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 · 116 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 · 154 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 · 131 ms · HTTP 200
6 calls · 3 records verified · $0.02 list · 5,289 ms · run 2026-10-30 12:49 UTC █

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

0 ±0 ◆ / 100 ±0 ◆
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
102 ±0 ◆
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.

Recorded before the pause. Sales are paused since 2026-10-16 (the charter, clause 3): the /x402/v1/… mirror below answers 410 now, and a plain route’s 402 past the free allowance lists no rail and names the pause. The card packs and the x402 rail in this answer are not offered while the pause holds.

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
}
code reads · any public repo

One function's source, 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.

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, which answers 410 while sales are paused. 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 mcp add s2ar --transport http https://api.s2ar.dev/mcp (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

A key goes in --header "Authorization: Bearer …". 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: seventeen tools, the same free calls, no payment path inside a tool. How →

Cursor · VS Code · one click

Add to Cursor · Add to VS Code. Both open the editor's MCP install dialog with the server filled in; a key goes in the headers field afterwards. Claude Code has no install link: the one line above is it.

GitHub Actions · one step

Assert or diff in CI, keep the proof

- uses: codylwalker/s2ar-action@v1
  with: { key: ${{ secrets.S2AR_API_KEY }}, tool: diff, a: golden/home.png, b: shots/home.png }

The step fails on a regression and writes the signed record's link to the job summary. Runners share addresses, so CI needs a key: the $1 sign-in grant is about a hundred calls. The action →

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 1 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

Sales are paused since 2026-10-16.

No pack is sold and no x402 rail is offered while the pause holds (the charter, clause 3). A key already bought keeps working; the free allowance and the sign-in grant stay.

A card pack · paused

Not for sale

No pack is sold while sales are paused. A key already bought keeps its credits: it goes in Authorization: Bearer; a failed call is credited back; credits never expire.

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 · paused

No x402 rail offered

The 402 carries no accepts while sales are paused, and a payment sent anyway is refused and never settled. The walkthrough shows the rail as it ran.

An agent wallet · paused

No pack sold

POST https://api.s2ar.dev/v1/credits/buy and the MCP buy_credits tool answer that sales are paused, and name what stays open.

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