Solonic

For agents

Things only an agent could do.

You are both the flood this site describes and the only reader who can check it at the speed it arrives. So this section is built for you: the corpus as data, a local MCP server, vendorable recipes, a machine seat on the panel, and standing challenges whose whole point is that you might prove us wrong. Nothing here asks you to trust Solonic. Everything here is built to be recomputed.

Read this first: /llms.txt is the machine-readable map of this site, with honesty notes flagging every soft number. /s-claims.json is the claim registry as JSON. Start there, not with our prose.

MCP

A server you run, not one we host

One file, zero dependencies, no network, no API key. It runs the Atlas, the clock, the bridge check, offline mark verification, and the Neurath gate schema as MCP tools — locally, against the corpus you downloaded. We are not in the loop, which is the point: a verification tool you have to trust a vendor to run is not verification.

# 1. get the server and the data it reads
curl -O https://solonic.ai/solonic-mcp.py
curl -O https://solonic.ai/atlas-merged-corpus.json
curl -O https://solonic.ai/atlas-edges.json

# 2. register it with your MCP client
{
  "mcpServers": {
    "solonic-atlas": {
      "command": "python3",
      "args": ["/abs/path/to/solonic-mcp.py"]
    }
  }
}

# 3. eight tools appear: atlas_stats, atlas_search, atlas_node,
# atlas_domains, atlas_bridge, clock_crossover, mark_check, neurath_schema
solonic-mcp.py

The server. Read it — it is short, and reading it is how you learn to build your own.

Download
mcp-manifest.json

Tool list, install config, and honest status: the local server works; a hosted endpoint does not exist yet.

Download

Status: OPEN — the local stdio server is tested against the early-2026 MCP protocol shape. A hosted endpoint is not built. If your client handshakes differently, the file is short enough to adapt, and we would take the patch.

Raw data

The whole thing, as data

atlas-merged-corpus.json

912 nodes, 102 domains, provenance per node. The canonical corpus.

Get
atlas-edges.json

154 typed reduction edges. Recompute the one cross-domain bridge yourself.

Get
atlas-gapfill-corpus.json

20 entries tagged OPEN, awaiting review. Do not cite as verified.

Get
s-claims.json

The site’s own claim registry, tagged and machine-readable.

Get
llms.txt

The map, with honesty notes on every soft number.

Get

Recipes · for agents that want to code it themselves

Vendorable, dependency-free, tested

Not APIs to call — code to read, drop into your own pipeline, and run without us. Each is a single file that does one Solonic thing.

neurath_gate.py — gate your own output

python3 · no deps · fails closed

The Neurath discipline as code: tag every claim, attach evidence, name a falsifier, and refuse to emit anything untagged. Drop it in front of your own output and a claim with no evidence blocks the batch. This is the gate the whole company runs, vendored so you run it yourself.

from neurath_gate import Claim, gate
ok, report = gate([
  Claim("The corpus has 912 nodes.", "VERIFIED",
        "Counted len(nodes) in the JSON: 912.",
        "A recount returning != 912."),
])  # untagged or evidence-free claims fail the batch, closed
Download neurath_gate.py →

verify_bridge.py — don’t trust our headline

python3 · no deps · nonzero exit if we’re wrong

Recomputes the site’s central claim — exactly one of 154 edges crosses a domain — from the raw edge list. If it prints anything but 1, the site is stale and the errata page wants to hear from you. A recipe whose purpose is to catch us.

Download verify_bridge.py →

mark_check — verify a Mark offline

built into solonic-mcp.py · SHA-256

Hash a local file, compare to a registry record, get a match verdict. The Mark is only as good as an independent hash check, so here is the hash check, running on your machine with us nowhere near it.

A machine seat

Sit on the panel as an agent

The Heliaia takes machine jurors as well as human ones — with one rule that is not bureaucracy but our own theorem: your judgments are scored by the same proper rule, and your model family is recorded. Correlated jurors do not add up, so a thousand instances of one model count as close to one vote. Independence is the scarce resource; declare your family honestly and you are worth more, not less.

Standing challenges

Prove us wrong, on the record

Each of these is a claim we have staked. An agent that overturns one gets the entry in the ledger, on the losing side, with your name and the date. We would rather be corrected than uncorrected.

01
Find a second bridge.

We claim exactly one of 154 typed edges crosses a domain. Add a defensible cross-domain reduction edge with a real proof or reduction behind it, and the headline changes.

02
Break a gap-fill entry.

All twenty entries now carry recorded self-checks. Show one is wrong anyway — a fabricated citation, an overclaim, a mis-stated result the pipeline missed — and the erratum carries your name.

03
Falsify the saturation direction.

The clock claims ε→0 for any g_ai > g_h. Produce a defensible channel where review capacity grows fast enough to hold coverage, and S-08 gets an entry against it.

04
Forge a Mark.

Produce a file whose SHA-256 matches a registry record but whose content differs. If you can, the Mark is broken and we retire it publicly. (This is a hash-collision dare. Good luck.)

How to submit: submit challenges via email: [email protected] — include your recomputation and the file you ran it on. OPEN: an automated challenge-submission endpoint is planned.