Every product below writes into the same tamper-evident SHA-256 chain. Most of what follows needs no account at all — the proof routes are open on purpose, because a proof you can only check with the prover's permission is not a proof. Base URL: https://sebbi.pro
The official clients are open source (source on GitHub), have no runtime dependencies, and send only SHA-256 fingerprints. Python releases are published from that public repository with PyPI Trusted Publishing and carry a publish attestation naming the exact commit. Every receipt gets a public page at https://sebbi.pro/r/<id> anyone can check.
pip install sebbi # Python npm install sebbi # JavaScript / TypeScript
import sebbi
@sebbi.receipt("refund-decision")
def decide_refund(order):
return {"refund": True}
decide_refund({"id": 7})
print(sebbi.last().url) # https://sebbi.pro/r/...
| Where your agents run | One line |
|---|---|
| OpenTelemetry (Python) | pip install "sebbi[otel]" then from sebbi.integrations.otel import instrument; instrument(). Every agent run and tool call you already trace gets a receipt, and the span carries sebbi.receipt.id / sebbi.receipt.url into Datadog, Grafana, Honeycomb, Langfuse or Phoenix. Recognises the OpenTelemetry GenAI conventions, OpenInference and Vercel AI SDK spans. |
| OpenTelemetry (JavaScript) | new SebbiSpanProcessor() from sebbi/otel. With the Vercel AI SDK, turn on experimental_telemetry and every ai.toolCall is sealed. |
| Prove a trace | sebbi verify-otlp traces.json recomputes every span's fingerprints from an OTLP/JSON export and compares them with its sealed receipt: MATCH or MISMATCH, without trusting us or the operator. |
| Vercel AI SDK | wrapTools(tools), or give the agent its own tools with sebbiTools() from sebbi/ai-sdk (seal, check, reverse). Guide |
| CrewAI | Crew(..., step_callback=step_callback, task_callback=task_callback) from sebbi.integrations.crewai |
| LangChain / LangGraph | config={"callbacks": [SebbiCallbackHandler()]} from sebbi.integrations.langchain |
| OpenAI Agents SDK · MCP | sebbi.integrations.openai_agents · sebbi.integrations.mcp, or connect any MCP client to https://sebbi.pro/mcp (verified publisher on the official MCP Registry) |
| Any HTTP client | POST /v1/receipts with {"records":[{"id","hash","input_hash","output_hash","label","ts"}]}; check with GET /v1/receipts/{id}. 1,000 a day free with no account, 100,000 a day with a key. |
| Reversals | sebbi.reverse(receipt, "reason"): nothing is deleted; the original is shown REVERSED, linked to a sealed reversal receipt. Only whoever sealed the original can reverse it. |
No account needed. Fingerprint your content locally, send the hash, get a sealed receipt back:
curl -X POST https://sebbi.pro/api/post/seal \
-H "Content-Type: application/json" \
-d '{"fingerprint":"<64-char sha-256 of your content>"}'
{
"sealed": true,
"seal": "43ac8582…", // the chain block hash
"block_index": 1042,
"sealed_at": 1789420000.12,
"code": "43ac85820f19" // 12-char public verify code
}
Three notaries, one pattern: POST a fingerprint to seal, GET to verify. All public, all free. Re-sealing the same fingerprint returns the original receipt with already_registered: true.
POST /api/post/seal — body {"fingerprint":"<sha256>"}.
GET /api/verify-post?content=<sha256> — returns {"verified":true,"block_index":…,"sealed_at":…,"seal":…}, else {"verified":false}.
POST /api/identity/seal — body {"fingerprint":"<sha256>", "public":true, "profile":{…}}. With public set, a limited display set (name, title, bio, linkedin, facebook, org) is stored so a checker can show them; otherwise only the fingerprint is sealed.
GET /api/identity/check?code=<12+ chars> — short code or full fingerprint.
POST /api/payment/seal — body {"fingerprint":"<sha256 of the real bank details>", "display":{"business":…,"sort_masked":…,"account_masked":…}}. Only masked display fields are stored; the true details never are.
GET /api/payment/check?code=<12+ chars>&fp=<optional full sha256> — returns MATCH, MISMATCH or NO_SEAL. Either way the check itself is sealed and returned as a receipt, giving provable evidence of the check under PSR reimbursement rules.
# 1. fingerprint locally — content stays with you import hashlib, requests fp = hashlib.sha256(content.encode()).hexdigest() # 2. seal the fingerprint r = requests.post("https://sebbi.pro/api/post/seal", json={"fingerprint": fp}).json() code = r["code"] # store this next to your record # 3. anyone verifies later — no account v = requests.get("https://sebbi.pro/api/verify-post", params={"content": fp}).json()
Put that where your system creates the thing worth proving — a post published, an invoice issued, a profile created — and every record from then on carries tamper-evident proof automatically.
Score an event, get a verdict, sealed before the response returns. Deterministic: identical inputs always produce identical outputs.
curl -X POST https://sebbi.pro/api/govern \
-H "Authorization: Bearer YOUR_KEY" \
-H "Content-Type: application/json" \
-d '{
"user_id": "user_123",
"action": "payment",
"amount": 49.99,
"country": "UK",
"device_id": "dev_abc",
"anomaly": 0.1,
"device_risk":0.05
}'
| Field | Type | Meaning |
|---|---|---|
| user_id | string | Your stable identifier for the acting user. Trust is learned per user_id. |
| action | string | What they're doing — payment, login, message, anything. |
| amount | number | Monetary value if relevant, else 0. Log-scaled internally. |
| country | string | ISO-style code. Country changes and off-allowlist jurisdictions raise score. |
| device_id | string | Device identifier for velocity correlation. |
| anomaly | 0–1 | Your behavioural-anomaly signal, if you have one. 0 if not. |
| device_risk | 0–1 | Your device-risk signal, if you have one. 0 if not. |
Verdicts: score < 0.35 → ALLOW · < 0.70 → CHALLENGE · else BLOCK. Every verdict carries plain-language reasons. Trust is earned slowly on ALLOW and lost eight times faster on BLOCK, so burst attacks self-amplify.
{
"decision": "CHALLENGE",
"challenge_url": "https://sebbi.pro/verify-challenge?token=…",
"challenge_status_url": "https://sebbi.pro/api/challenge/status?token=…",
"challenge_expires_in": 900
}
Surface challenge_url to your user; they confirm or deny on the hosted page; the resolution is sealed as its own block; you poll the status URL until resolved: true. Tokens are stateless and HMAC-signed. Three lines: if CHALLENGE → surface URL → poll.
The demo module runs the real engine with no account on any route — it is what the public Proving Ground is built on.
| POST /x/demo/govern | A real decision through the live engine, sealed into the production chain. |
| POST /x/demo/review | Opens a review case with the verdict withheld and a server-measured clock running. |
| POST /x/demo/commit | Commits your call before the machine verdict is revealed. |
| GET /x/demo/stats | Aggregates across everyone who has tried it, including how many committed in under two seconds. |
Every govern response includes receipt_seq: a per-key sequence issued in the same transaction as the chain write, gapless by construction. Store them. If you ever hold receipts 46 and 48 with no 47, a record has been omitted — provable by arithmetic.
| Endpoint | Returns |
|---|---|
| GET /api/verify-chain | no key Whole-chain integrity: {"valid":true,"blocks":N,"tip":…}. Anyone can run it. |
| GET /api/inclusion?hash= | no key Whether a full 64-char receipt hash is sealed, with block index and sequence. |
| GET /api/coverage | key Reconciliation in one call: receipts issued vs blocks sealed, complete: true/false. |
| GET /api/pulse | key Your last hour — verdict mix, recent decisions with reasons, chain tip. |
| GET /api/regulation-map | no key Versioned, hash-sealed map of engine features to legal obligations. |
| GET /api/spec | no key This API describing itself, machine-readable. |
| GET /x/stats | no key Public aggregates — chain growth, verdict mix, dwell distribution. Nothing scoped to a customer key. |
Chain tips are timestamped into Bitcoin through OpenTimestamps. A proof is pending when the calendar accepts it and confirmed only once the transaction lands and the proof is upgraded. Both states are reported as what they are, everywhere, because your own verifier will say it first.
| GET /x/ots/status | no key Proof counts, pending vs confirmed, first attempt date. |
| GET /x/ots/list | no key Every proof on file. |
| GET /x/ots/proof | no key The raw .ots bytes, base64. Verify with the standard opentimestamps client — nothing of ours required. |
| POST /x/ots/upgrade | key Re-fetches proofs from the calendars to confirm them. Also runs hourly on its own. |
Anyone can show you a log of what happened. The hard questions are whether anything is missing, and whether the log you were shown last quarter is the same log you are being shown now.
A sorted Merkle tree per period, with the leaf count committed before any export is requested. Absence is proved by returning two adjacent leaves with consecutive indices: nothing can sit between them. Erasure is handled by tombstone — the payload is deleted by your system, the leaf is retained, the erasure event is sealed. That proves a record existed and was erased while holding none of its content.
| GET /x/complete/periods | Which periods are committed, and how many days after each closed. |
| GET /x/complete/root | The committed root and exact leaf count for a period. |
| GET /x/complete/prove?period=&value= | Inclusion proof, or an absence proof with the two neighbouring leaves. |
| GET /x/complete/spec · /verify | The rules, and a checker. |
| POST /x/complete/commit · /erase | key Only closed periods commit, and each commits once. |
An ordered RFC 6962 Merkle tree over every audit hash in write order, deliberately unmodified so existing Certificate Transparency verifiers work against it.
| GET /x/consistency/root | Current tree size and root. |
| GET /x/consistency/ancestor?tip= | Hold any tip we ever served and prove it is still on this chain. A fork returns 409 with the evidence. |
| GET /x/consistency/proof?first=&second= | RFC 6962 consistency proof that the log at one size is a prefix of the log at another. |
| POST /x/consistency/checkpoint | key Seals the current size and root into the chain so it gets anchored. |
complete is sorted — it answers "is this in, or provably absent". consistency is ordered — it answers "did this log only ever grow". The roots deliberately do not match, and anyone comparing them is comparing the wrong things.The scoring maths is never disclosed. No route returns source, weights, thresholds or intermediate values — only a one-way SHA-256 fingerprint of the deployed decision function. Proof works by public challenge instead: POST any inputs, the run is sealed, and resubmitting identical inputs later must give an identical verdict under an unchanged fingerprint.
curl -X POST https://sebbi.pro/x/replay/challenge \
-H "Content-Type: application/json" \
-d '{"inputs":{"action":"payment","amount":49.99,"trust":0.5,
"v60":1,"v5m":1,"v1h":1,"device_risk":0.05,
"anomaly":0.1,"country":"UK","country_shift":0}}'
| POST /x/replay/challenge | Run any inputs. Sealed. Resubmit later and compare. |
| GET /x/replay/history?input_hash= | Every run of those exact inputs, with verdicts and fingerprints. |
| GET /x/replay/self | Reproduction rate across a sample. |
| GET /x/replay/fingerprint | The code fingerprint of the deployed decision function. |
| POST /x/replay/check · /attest | key |
Each decision can record the receipt hashes of its inputs and which chain each came from. The graph then composes, and every hop is verifiable through routes that already exist. External hops are named with a verification plan pointing at the other party's own host — never resolved or certified by us.
| GET /x/lineage/trace?receipt= | Upstream: what fed this decision. |
| GET /x/lineage/impact?receipt= | Downstream: which decisions declared a dependency on a retracted or faulty input. Article 20 corrective action. |
| GET /x/lineage/receipt?receipt= | A portable, self-contained proof document that travels with an output. |
| POST /x/lineage/declare | key Records an edge. |
Everything above proves what your system did. This proves it was entitled to. An agent acts; it got its authority from another agent, which got it from a system, which got it from a person. A permission check answers one hop. An audit log describes the aftermath. Neither derives anything, so neither can see authority widening three delegations back.
Every grant points at a parent and terminates at a named human. Scope, limits, purpose and validity must narrow at every hop, and the whole chain is re-derived at the instant of execution rather than trusted from the instant of issue.
A root must be issued by a human, must state a purpose, and must expire. Authority with no stated purpose cannot be checked for intent drift later, so it is refused.
curl -X POST https://sebbi.pro/x/continuity/issue \
-H "Authorization: Bearer YOUR_KEY" \
-H "Content-Type: application/json" \
-d '{"issuer":"you@company.com","issuer_kind":"human",
"subject":"orchestrator",
"scope":["payments.refund","payments.read"],
"constraints":{"max_amount":5000,"allowed_currency":["GBP"]},
"purpose":"resolve customer refund complaints",
"purpose_tags":["refunds","support"],
"not_after":1786400000,
"delegations_left":2}'
{ "grant": "g_9ec009c0a02345169788", "depth": 0,
"risk_accepted_by": "you@company.com",
"digest": "…", "block_index": 842 }
Same endpoint with a parent. A child may narrow and never widen; raising max_amount above the parent's is refused with the axis named.
risk_accepted_by and cannot inherit one — handing an agent the power to hand authority on again is a new risk that did not exist when the person above signed up to it. A lineage where nobody has accepted the risk refuses to act at all.curl -X POST https://sebbi.pro/x/continuity/exercise \
-H "Authorization: Bearer YOUR_KEY" \
-d '{"grant":"g_9ec…","action":"payments.refund",
"params":{"amount":150,"currency":"GBP"},
"purpose_tag":"refunds"}'
{ "verdict": "ALLOW",
"authority_verdict": "ALLOW", "risk_verdict": "ALLOW",
"authorised_by": "you@company.com",
"executed_by": "refund-agent",
"risk_accepted_by": "you@company.com",
"delegation_depth": 1,
"lineage": [ … every hop, root first … ],
"lineage_digest": "…", "params_digest": "…",
"block_index": 843 }
A refusal names where it broke rather than simply denying:
{ "verdict": "BLOCK",
"broken_at": "g_mid…", "broken_invariant": "boundary_integrity",
"reasons": ["amount=900 exceeds max_amount=200"] }
| Verdict | Meaning |
|---|---|
| ALLOW | Every invariant held and the risk engine agreed. Derivable from a valid human grant. |
| CHALLENGE | Nothing provably broken, nothing provably fine — a purpose the grant does not carry, a wildcard too broad to review, or a parameter no ancestor constrains. Escalated rather than guessed. |
| BLOCK | An invariant failed. The response names the grant and the invariant. |
An ALLOW is a decision about a request that may not be the request that ran. confirm re-derives the parameter digest from what actually executed, enforces the validity window, and can be spent exactly once — enforced by a unique index rather than a read followed by a write, so concurrent attempts cannot both win.
curl -X POST https://sebbi.pro/x/continuity/confirm \
-H "Authorization: Bearer YOUR_KEY" \
-d '{"evaluation":"e_05da…","action":"payments.refund",
"params":{"amount":150,"currency":"GBP"},"outcome":"executed"}'
POST /x/continuity/revoke — body {"grant":"g_…","reason":"…"}. Transitive by derivation: everything beneath stops evaluating immediately, with no descendant needing to be found. Actions already evaluated stay exactly as they were decided — revocation does not rewrite history.
| Endpoint | Notes |
|---|---|
| GET /x/continuity/spec | no key The derivation rules in full, sufficient to reimplement the evaluator. |
| GET /x/continuity/decisions?limit= | no key Real sealed evaluations. Blocks listed beside allows. |
| GET /x/continuity/decision?evaluation= | no key One sealed decision in full. |
| GET /x/continuity/trace?grant= | no key The whole authority path, root first, with effective constraints across it. |
A well-formed grant that was never issued passes every internal check, because issuer, scope and approver all arrive on the request. So a grant sealed at tree size M, plus an independent peer that accepted a head at size N ≥ M at time T, proves the grant existed before T in a log we cannot write to. Back-dated grants die without a new protocol.
| GET /x/witnessed/grant?grant= | Whether a grant is externally witnessed, and how many minutes it sat unwitnessed. |
| GET /x/witnessed/heads · /status | Accepted peer heads, coverage strength, and the collusion limit stated openly. |
| POST /x/witnessed/submit | key |
A grant can name the facts its standing depends on: a fact in the sealed fact register, a human kill switch that must be live, or a value at a public https address. At the moment an action binds, every condition in the lineage is evaluated against the live fact. If one no longer holds, the action does not bind, even though the grant itself is still valid, and the refusal is sealed with what was observed. Conditions fail closed. A change to a fact the lineage does not depend on refuses nothing. Tested on production in four cases against frozen code: /standing.
| POST /x/conditions/fact | key write a fact in your namespace; every change sealed |
| POST /x/conditions/attach | key {grant, conditions, reason?}, grant issuer only |
| GET /x/conditions/check | no key evaluate a grant's conditions now |
A proof you can only check with the prover's own online tool is a reassurance. So any authority decision exports as a self-contained signed bundle, and the checker runs on your machine with the network off.
curl -sO https://sebbi.pro/verify-authority.py curl -s "https://sebbi.pro/x/continuity/proof" | python3 verify-authority.py -
With no evaluation the proof route returns the most recent decision, so you can start knowing nothing.
{ "bundle_version": "1.0",
"issued_by": { "algorithm": "Ed25519", "public_key": "…" },
"decision": { "verdict": "ALLOW", "lineage_digest": "…",
"params_digest": "…", "broken_at": null },
"request": { "action": "payments.refund", "params": {…} },
"lineage": [ … every grant as it stood at that instant … ],
"chain": { "audit_hash": "…", "block_index": 843 },
"rules": { … how every digest and the signature are computed … },
"signature": "…" }
The verifier does four separate things, each able to fail on its own: signature (Ed25519 over the canonical bundle), integrity (every digest recomputed from the fields in front of it), derivation (the authority path re-run from the published rules), and agreement (its verdict compared with ours — a disagreement is reported as our failure, not its).
script_sha256 at /x/verifier/status against what you downloaded, and read it before you run it.When authority cannot be derived you do not get a bare BLOCK. The bundle carries the grant and the invariant that failed, and the verifier independently reproduces that failure at the same hop. An agent that can prove it was not authorised is a different object to one that was merely denied — and it is what a counterparty needs when an action does not happen.
RESULT: VERIFIED - BLOCK This is a proof that the action was NOT authorised, and where it failed. Checked with no network access, no dependencies, and nothing taken on the issuer's word except the meaning of their public key.
aileash_verify.py is the auditor's tool: one file, no dependencies, never touches the network. It checks completeness inclusion, absence, RFC 6962 ancestry and prefix proofs, and replay stability. Run --selftest and it builds trees internally and confirms that tampered proofs and a forged prefix are rejected.
| GET /verify-authority.py | The authority verifier, as a plain file. |
| GET /x/verifier/status | Its size and SHA-256, to check what you downloaded. |
| GET /x/continuity/pubkey | The Ed25519 public key, RFC 8032, verifiable with any standard library. |
Point it at any sealed block and it compiles one report: the decision exactly as sealed, who did it — the account that sent it, the end user it was about, their device and history, any authority they acted under, any human who reviewed it — and where it came from: the IP address, the full forwarded chain, user agent, origin, referer and request id. Then the proofs: the block rehashed, linked both ways, the whole chain re-verified from genesis to that block, a Merkle inclusion proof, the account's receipt sequence checked for gaps, the public beacons either side of it, and the Bitcoin anchor that covers it.
Issue it and the report's own digest is sealed into the chain, so the document you hand an auditor, insurer or court is itself on the record. Anyone can check an issued digest without seeing what is in the report.
Open it in a browser at sebbi.pro/dossier: block number, your key, one tap. It prints to PDF and downloads as JSON.
| Endpoint | Returns |
|---|---|
| GET /x/dossier/report?block=N | key The full report for a block your key sealed. receipt=<audit hash> works instead of block. |
| POST /x/dossier/issue | key {"block":N}. Builds the report and seals its digest. Returns the report, the digest and the block it was sealed in. |
| POST /x/dossier/attach | key Adds your end user's context to a block you just sealed: ip, user_agent, session_id, actor, actor_role, location, channel, note. Must arrive within 15 minutes of sealing; the report shows how long after. |
| GET /x/dossier/verify?block=N | no key The public half: integrity and time proofs only, no personal data. |
| GET /x/dossier/check?digest= | no key Whether a report with exactly this digest was issued, and where its digest was sealed. |
| GET /x/dossier/spec | no key How the report is built, as data. |
# the full report for block 8123
curl -s "https://sebbi.pro/x/dossier/report?block=8123" \
-H "Authorization: Bearer $SEBBI_API_KEY"
# straight after a govern call: attach who your end user was
curl -s -X POST https://sebbi.pro/x/dossier/attach \
-H "Authorization: Bearer $SEBBI_API_KEY" -H "Content-Type: application/json" \
-d '{"block":8123,"ip":"198.51.100.9","user_agent":"Mozilla/5.0 …","actor":"j.smith","session_id":"s-77"}'
# seal the report and hand over the digest
curl -s -X POST https://sebbi.pro/x/dossier/issue \
-H "Authorization: Bearer $SEBBI_API_KEY" -H "Content-Type: application/json" -d '{"block":8123}'
{
"subject": { "block_index": 8123, "verdict": "CHALLENGE", "score": 0.52, "reasons": [...], "sealed_at_uk": "…" },
"decision": { "event": {…as sealed…}, "result": {…as sealed…} },
"who": { "account": { "name", "organisation", "email", "plan", "key": "al_live_…a1b2" },
"subject_user", "device", "subject_history", "authority", "human_review" },
"where": { "ip", "forwarded_chain", "user_agent", "origin", "referer", "request_id", "end_user", "records": [...] },
"integrity": { "block_hash_recomputes", "links_to_previous", "next_block", "chain_verified_genesis_to_here",
"merkle_inclusion": { "root", "leaf_index", "audit_path" }, "receipt_sequence": { "gapless" } },
"time": { "heartbeat": { "floor", "ceiling", "window_seconds" }, "bitcoin_anchor": { "state", "proof" } },
"linked_records": [...], "limits": [...], "digest": "…"
}
A chain the operator can rewrite forward is a claim. The answer is not a better promise, it is a copy held by somebody else. Chains exchange tips on an hourly cycle; once a peer holds our tip it sits in their record, not ours.
Joining is free and ungated, permanently. The protocol code never checks subscription status. There is no membership list, no seat to grant and none to revoke — the roster is a record of who submitted and when, with first-seen dates anyone can verify.
| GET /x/witness/tip | Our current head. A peer cannot seal what it cannot read, so this is public on purpose. |
| POST /x/witness/observe | Submit your tip. No account — a witnessing endpoint that needs an account is a customer list, not a witness network. Never rejects a well-formed submission. |
| GET /x/witness/attest · /spec | What was sealed, and the protocol in full. |
| GET /x/roster/list | Every chain that has submitted, with first-seen dates and elapsed-time status: current, stale, silent. |
| GET /x/mutual/peers · /status | Who we fetch from, and how the outbound cycle is running. |
| GET /x/praxis/status | The signed lane — customer-held Ed25519 keys rather than a shared secret. |
| GET /x/signed/spec | The signed submission contract. |
current, stale and silent measure elapsed time only — nothing else.Sequence is the only property that cannot be retrofitted. Content can be fabricated, timestamps argued over, a log rebuilt — but a commitment made before the information existed cannot be reverse-engineered afterwards. Ten checks, published as a discovery document any vendor can serve from their own domain.
rule_binding commit_before_reveal completeness_proof absence_proof consistency_proof reproducibility mutual_witnessing external_anchoring authority_tokens reconciliation
Each check declares supported and, separately, demonstrable_publicly — because "we built it" and "you can check it without an account" are different claims, and separating them is what stops an operator marking their own homework.
| GET /.well-known/ordering-test.json | The discovery document. base_url is derived from the Host header, so the file publishes whichever domain serves it. |
| GET /x/standard/status · /hash | Module state and the document digest. |
| GET /self-check | The runner as a page: reads the published document and runs every check in declared order. Four outcomes, and "reachable" never counts as a pass. |
| GET /x/register/spec | The Safe AI Registry — self-service listing, absence proofs, RFC 6962 consistency, and revocations that seal rather than delete. |
The word does three jobs, so here they are apart.
| Kind | Route | What it is |
|---|---|---|
| Cost packs | /x/packs/ | An open library of decision rules over nine live cost signals. Free to read, write, fork and publish. Running one needs a key. |
| Risk packs | /api/signal-pack/ | Weighted risk signals — bias, adverse impact, explainability gap. Keyed, private by default. |
| Evidence packs | /x/pack/ | The quarterly auditor document: every block re-verified, links rewalked, receipt sequence checked, with an unbroken-since date. |
Nine signals: exposure, size, ask, depth, tools, loop, burst, grind, novelty, plus raw counts and a composite score. Rules are written in a small expression language with no function calls, attribute access or strings in the grammar — nothing reaches eval. Every rule requires a stated reason or publishing fails.
A pack can return allow, downgrade, challenge or block. It can never return serve, and it can only make the engine's verdict stricter, never weaker — capping is reported rather than silently applied.
| GET /x/packs/list · /get · /spec · /status | no key Browse and read every published pack, including its rules and reasons. |
| POST /x/packs/validate · /publish · /fork | no key Publishing seals the pack's fingerprint with the date. Forking records the parent, so lineage is visible rather than argued about. |
| POST /x/packs/run | key Executing a pack against real traffic is the metered part. |
| GET /x/pack/spec | no key What the pack contains and how each check is performed. |
| POST /x/pack/preview · /render · /issue | key issue seals the pack's own digest, so the document cannot be edited after the fact. |
One Python file, standard library only, local SQLite with WAL, its own audit chain, daily sealed backups. Every decision, the chain and the database stay on your hardware.
| GET /health · /stats · /snapshots | Local operational state. |
| POST /govern | The decision, locally. Requires a matching bearer. |
| GET /verify-chain | Rewalks and rehashes every block on your own machine. |
| GET /tip | Its head, public on purpose — a peer cannot seal what it cannot read. |
| POST /witness/observe | Open on purpose. Your on-premise chain can be witnessed by chains you choose. |
| GET /peers | Who has been seen witnessing this engine. |
python sebdog_engine.py --token-file licence.token --port 9090 --chain your-chain-name
That last pair of routes is the point of it: the only configuration where the data never leaves your building and the record is still externally witnessed. Pair it with meshwitness.py to run the exchange.
| File | What it does |
|---|---|
| sebbi (PyPI, npm) | The official open-source clients. pip install sebbi / npm install sebbi. Decorator or wrapper per action, background batching, never raises into your code, OpenTelemetry processor and exporter, framework integrations, reversals and the verify-otlp checker. See Install. |
| aileash.py | Drop-in client, stdlib only. Decorator, context manager or direct check. Fails closed by default — gate unreachable means the agent stops — with an explicit on_error="allow" opt-out. Raises BudgetExhausted and HumanReviewRequired separately, because topping up does not clear a review halt. |
| sebbi_sdk.py | Zero-dependency SDK, @witness() decorator. Canonical-JSON SHA-256 fingerprints of inputs and outputs, hash-only egress, background daemon thread, batching, disk spool on outage and replay. Never blocks the caller, never swallows the caller's exception. Adds about 0.1 ms per call. |
| leashproxy.py | The chokepoint. Holds the model provider's key so the agent never sees it, charges before forwarding, and at zero balance refuses with 402 without the call ever reaching the model. Strips any provider credential an agent tries to forge. |
| aileash-capture.js | Browser widget using capture tokens rather than API keys, with server-measured dwell. |
| sebbi_tokensaver.py | The cost client. Change one line — base_url to http://127.0.0.1:8788. Fails open, caches locally, queues records on outage. Prompts and answers never leave your machine; --offline works with no account at all. |
Give an agent a budget and terminate it when the budget is gone. charge is the gate: it returns allowed true or false and seals every charge into the chain, so the spend record and the decision record are the same record. Balances are integer millipence — no floats.
| GET /x/wallet/spec | no key |
| POST /x/wallet/charge · /quote · /simulate | key simulate is a dry run: how far does a runaway loop get on this balance, without spending anything. |
| POST /x/wallet/topup · /subscribe · /devices · /review · /clear | key |
| /x/publish/ | Publication sealing. Fetches a URL server-side, hashes the exact bytes served with no normalisation, and seals url + hash + fetch time. Re-sealing builds an uneditable revision history. |
| /x/codebase/ | Dated authorship evidence. Hashes every file into one ordered manifest root and seals it with your authorship declaration. File contents never leave; only root, count and bytes are public. |
Every response from the gateway and from /api/govern carries one standard HTTP header: the decision, the sealed block, a SHA-256 fingerprint of the exact request, and where anyone can verify it. On 26 October 2026 the format was submitted to the IETF as Internet-Draft draft-dobson-ai-decision-receipt.
AI-Decision-Receipt: v=1, issuer="sebbi.pro", decision=ALLOW, score=0.12, block=1042, seal="<64-char sha-256>", req="<sha-256 of your request body>", call="GC-7Q2M9X4KDP", verify="https://sebbi.pro/forever?block=1042"
Syntax is a Structured Field Dictionary. v, issuer and decision are required; block, seal and verify are required when the decision was sealed. The draft adds an optional agent member carrying the key id of a verified HTTP Message Signature, so the receipt binds the agent's identity to the decision. Receivers must ignore members they don't recognise. To check one: hash your request body and compare to req; fetch verify and confirm the block's hash equals seal; then check the Bitcoin proof with OpenTimestamps. POST /x/gateway/parse parses any header value for you. Full text: /standard/ai-decision-receipt.
POST /x/planlock/commit sebbi engine — before the agent reads anything untrusted: {task, user_values:[…], steps:[{tool, max_calls, args:{name: rule}}], ttl_minutes}. Rules: {"equals":v} {"one_of":[…]} {"from_user":true} {"max":n} {"pattern":"regex"} {"any":true}, plus "untrusted_ok":true to allow values from untrusted data. Returns plan_id and a plan token.
POST /x/planlock/check sebbi engine — before every tool call: {plan_id, token, tool, args, sources:{arg:"user"|"untrusted"|"tool"}}. BLOCK if the tool isn't in the plan, its calls are used up, an argument breaks its rule, or a protected argument came from untrusted data; otherwise ALLOW. Every check is sealed. POST /x/planlock/demo runs a scripted attack with no key. Spec: /plan-lock.json.
POST /x/mandate/issue sebbi engine — {subject, scope, max_amount, currency, payees, ttl_minutes, authorised_by}: the root mandate from a person. POST /x/mandate/delegate sebbi engine — {mandate, subject, scope?, max_amount?, payees?, ttl_minutes?}: a narrower mandate for the next agent; a wider one is refused. POST /x/mandate/check — an action against the whole chain back to the person. POST /x/mandate/verify no key — offline signature check plus live revocation. Every link is Ed25519-signed under /x/mandate/pubkey.
GET /x/jugular/check?id=JG-XXXX-XXXX no key — call before every action; returns {"live": true|false}. POST /x/jugular/create, /pull, /release, /grip — the holder's key authorises each; every pull and release is sealed. GET /x/jugular/history?id= — every sealed pull. An optional dead man's grip halts the switch when the holder stops renewing it. Every new account gets a switch; the account's own API key can pull it.
POST /x/oversight_keys/open — open a review case (an AI can open one and wait on /ok/OK-XXXX-XXXX.json). GET /x/oversight_keys/challenge then POST /x/oversight_keys/sign — the reviewer's live-typed sign-off: AGREE, OVERRIDE or STOP, with a Human Keys rhythm verdict, server-measured dwell time and a device-key signature. Cases can require two people on two device keys.
POST /x/frontier/act sebbi engine — the consequence firewall: {action, risk, inputs:[{source, trust, sha256?, text?}], human_confirmed?}; high-risk actions with untrusted context are HELD until a person confirms, and the taint receipt names every input. /x/frontier/memory and /memory_check — sealed agent memory. /x/frontier/dispute — an agent dispute pack against its mandate. /x/frontier/reasoning — sealed reasoning. POST /x/frontier/scan no key — the injection scanner. Spec: /frontier.json.
POST /x/proofpath/run — run any check on a record; results are live and free. With a paid key the run becomes a sealed certificate with a receipt page at /proof/r/<id>. /x/proofpath/prove_once proves one obligation for every control that asks for it (33 obligations: /x/obligations/map). /x/proofpath/push key pushes live records into the compliance file at /my-file. /x/proofpath/ask, /ask_state, /ask_submit run Ask for Proof between a buyer and a supplier.
Through the connector at /mcp: sebbi_record_template, sebbi_explain_check, sebbi_run_everything (all 755 checks on one record, a sealed scorecard SC-XXXX-XXXX with the highest-value fixes first), sebbi_scorecard, sebbi_readiness_check, sebbi_accessibility_scan, sebbi_log_incident, sebbi_energy_record, sebbi_ai_act. Without MCP: GET /x/mcpworks/template, /x/mcpworks/explain, POST /x/mcpworks/scorecard.
Every change to a compliance file becomes one Merkle root linked to the last and sealed; every decision the engine seals carries the root live at that second. GET /x/stateroot/proof no key reads a proof. Keyed: /x/stateroot/prove (one control at one moment), /prove_period, /prove_decision, /timeline, and the compliance gate — set a rule with /gate_rule, then POST /x/stateroot/gate {"action":"credit-decision"} returns ALLOW or HOLD with what is missing, sealed either way. Verify offline with /state/verify.py.
POST /x/lawlock/lock — {record | record_sha256, frameworks, org, reference}: seals the record's fingerprint with the exact rules it was checked against, the law in force that day, live bills, official sources and every result. GET /x/lawlock/ledger — the daily Law Ledger. Pages: /law-lock/LL-XXXX-XXXX.
POST /x/foresight/commit sebbi engine — {commitment, topic, reveal_after_minutes?, title?} where commitment = sha256(salt + "\n" + decision text), computed on your device. /x/foresight/reveal sebbi engine — {commit_id, salt, statement}. POST /x/foresight/verify no key checks any reveal. The count of commitments per topic is public.
Keyed: POST /x/modellineage/commit — seal a model setup's birth certificate (model, version, provider, prompt and policy fingerprints, settings, who put it live); /stamp binds a decision to it; /retire closes it. Public: /x/modellineage/public, POST /x/modellineage/verify.
Every sealed record has one permanent page: /fact/<ref>, /fact/<ref>.json, /fact/<ref>.svg, where <ref> is any record code, a block number or a notarised SHA-256. /fact/<ref>/court-pack is a printable evidence bundle with draft declarations. /fact-checker checks any proof with nothing from sebbi.pro. Discovery: /facts.json. MCP tools: sebbi_fact, sebbi_court_pack.
POST /x/aireceipt/seal — {answer, question?, ai?, context?}: an AI seals exactly what it said and returns a receipt link /said/AR-XXXX-XXXX for the person to keep. GET /x/aireceipt/get?code=. MCP: sebbi_answer_receipt, sebbi_answer_receipt_check.
POST /x/examiner/examine {url} — returns a Web Affidavit code, score and findings from the 22-point examination. POST /x/examiner/watch {code, email} — daily Drift Watch after email confirmation. Affidavits: /affidavit/WA-XXXX-XXXX plus /replay, /raw, /json. MCP: sebbi_examine.
GET /x/supplierscan/scan?domains=a.com,b.com — each domain's AI Integrity level, checked live and sealed. Spreadsheet form: /a/suppliers?domains=… (CSV) and /supplier-check/template.csv.
GET /x/origin/verify?id= — re-hash a stored Monop Studio video against its seal. POST /x/origin/check {id, sha256} — check a hash you computed yourself.
| /openapi.json | OpenAPI 3.1 for the proof, compliance and agent-safety APIs. |
| /.well-known/ai-catalog.json | Every product, page and machine file in one catalogue. |
| /ai-act.json | The EU AI Act Encyclopedia: every article, annex, definition and date. |
| /law-graph.json | Laws → duties → articles → checks → evidence, one graph. |
| /law.json | What each law asks of anyone running AI, and how to prove it. |
| /legislation.json · /legislation.rss | Live AI legislation: UK Parliament, US Congress, EU. |
| /ahead.json · /frontier.json · /undeniable.json | Where the industry says it is stuck; the frontier mechanisms; the public test protocol. |
| /teletext | sebbi TELETEXT. /teletext/<page>.txt plain text, /teletext/data/<page> JSON, /teletext/<page>.tti real Teletext files; /teletext/201/<block> for any block. |
| /school | Bot School: lessons as plain text at /school/<101-112>.txt, the whole school at /school/llms.txt, the exam by GET at /school/exam?name=&answers=&tip=. |
| Status | Body | Meaning |
|---|---|---|
| 400 | valid sha-256 fingerprint required | Notary needs a 64-char hex fingerprint. Govern needs all seven fields. |
| 401 | api_key_required / invalid_api_key | Send Authorization: Bearer YOUR_KEY. Public routes need none. |
| 403 | account_inactive | Account disabled — get in touch. |
| 404 | unknown_action | Read this one carefully. A method mismatch returns 404 with the accepted GET and POST lists in the body, not 405. A client that treats 404 as "endpoint missing" will report false failures on POST-only routes. |
| 409 | fork evidence / period already committed | Consistency found a fork, or a closed period was committed twice. |
| 423 | review required | A duplicate receipt halted the key. A person clears it. |
| 429 | quota_exceeded / rate_limit_minute / rate_limit_hour | Free tier spent, or per-key limits: 60/min, 1000/hr. |
| 500 | internal | Logged server-side; detail is never leaked to callers. |
Payloads are capped at 200KB. Public routes carry per-IP limits; keyed routes are metered per key.
Every change is booted and checked end to end before it ships.
Every module running on sebbi.pro, its version, and its routes. Generated from the modules themselves, so it cannot drift from what is deployed. Public routes need no key. Keyed routes take Authorization: Bearer YOUR_KEY. Every module also answers /x/<module>/spec or /x/<module>/status with its own description.
| Module | What it does | Routes |
|---|---|---|
counterfactualv1.0 | What would have changed the verdict, computed by inverting the real scoring function. | /x/counterfactual/decision /x/counterfactual/explain /x/counterfactual/probing |
demov1.0 | The Proving Ground. Run a live decision with no key, sealed into the production chain. | /x/demo/ /x/demo/stats POST /x/demo/commit POST /x/demo/govern POST /x/demo/review |
dossierv1.0.0 | Machine-proof report. Everything about one sealed block: decision, account, end user, IP and request, integrity and time proofs. | /x/dossier/check /x/dossier/spec /x/dossier/status /x/dossier/verify /x/dossier/attach /x/dossier/issue /x/dossier/report |
fingerprintv1.0 | Fires a fixed battery at any scoring endpoint to measure whether it runs this function. | /x/fingerprint/history /x/fingerprint/probe /x/fingerprint/self /x/fingerprint/spec /x/fingerprint/vectors |
humankeysv1.2.0 | Human Keys. Proof a human typed a text, scored by typing rhythm, owned by a device key and dated by Bitcoin. | /x/humankeys/challenge /x/humankeys/check /x/humankeys/pass /x/humankeys/spec /x/humankeys/status POST /x/humankeys/compare POST /x/humankeys/seal |
notaryv1.0.0 | Bitcoin Notary and Forever Proofs. Timestamp any fingerprint in Bitcoin; every chain block and Human Keys proof gets a proof anyone can check against Bitcoin without sebbi.pro. | /x/notary/ /x/notary/bundle /x/notary/checkpoints /x/notary/codebase /x/notary/hk /x/notary/lookup /x/notary/ots /x/notary/receipt /x/notary/spec /x/notary/status POST /x/notary/stamp POST /x/notary/verify |
packv1.0 | Evidence pack for a period. Re-verifies every block in range and seals the pack itself. | /x/pack/spec /x/pack/history /x/pack/issue /x/pack/preview /x/pack/render |
packsv1.0.0 | Signal Packs library. Write, validate, publish and fork for free; running one is keyed. | /x/packs/get /x/packs/list /x/packs/spec /x/packs/status POST /x/packs/fork POST /x/packs/publish POST /x/packs/validate /x/packs/run |
replayv1.0 | Determinism as a black box: send the same inputs later and the verdict must not move. | /x/replay/fingerprint /x/replay/history /x/replay/self /x/replay/spec POST /x/replay/challenge /x/replay/attest /x/replay/check |
rulebindv1.2.0 | Proves the ruleset version was hashed into the decision itself, without disclosing the rules. | /x/rulebind/ /x/rulebind/demo /x/rulebind/packs /x/rulebind/spec /x/rulebind/verify POST /x/rulebind/prove |
savingsv1.1 | Cost model behind /savings, with a sealed copy of any result. | /x/savings/status /x/savings/verify POST /x/savings/seal |
tokensaverv2.2.0 | Token saver platform side: published weights and rules, aggregate stats, receipt checks. | /x/tokensaver/spec /x/tokensaver/stats /x/tokensaver/verify |
| Module | What it does | Routes |
|---|---|---|
archivev1.0 | One self-proving archive file a day: every public block with its source text and a verifier. | /x/archive/day /x/archive/file /x/archive/latest /x/archive/manifest /x/archive/spec /x/archive/status /x/archive/verifier |
blocksv1.0.1 | Paged reads of the chain for operator tools. | /x/blocks/around /x/blocks/get /x/blocks/links /x/blocks/list /x/blocks/spec /x/blocks/status |
completev1.1 | Inclusion, absence and completeness proofs against committed period roots. | /x/complete/periods /x/complete/prove /x/complete/root /x/complete/spec POST /x/complete/verify /x/complete/commit /x/complete/erase |
consistencyv1.0 | RFC 6962 consistency proofs: the log only ever grew. | /x/consistency/ancestor /x/consistency/proof /x/consistency/root /x/consistency/spec POST /x/consistency/verify /x/consistency/checkpoint |
custodyv1.0.2 | Where independent copies of the archive are held, proven and counted. | /x/custody/holders /x/custody/keeper /x/custody/offer /x/custody/spec /x/custody/status |
disclosurev1.0.0 | The chain reset, put on the record inside the chain. | /x/disclosure/spec /x/disclosure/statement /x/disclosure/status |
genesisv1.0.1 | Chain identity: which chain this is, where it started, how to check it. | /x/genesis/chain /x/genesis/spec /x/genesis/status |
heartbeatv1.3.0 | Public random beacons sealed into the chain: a floor and a ceiling on every block's time. | /x/heartbeat/latest /x/heartbeat/spec /x/heartbeat/status /x/heartbeat/ticks /x/heartbeat/verify /x/heartbeat/window |
heldv1.0 | The tips sebbi.pro holds for other chains. | /x/held/peers /x/held/spec /x/held/status /x/held/tips |
otsv1.2 | OpenTimestamps proofs served raw, confirmed or pending, upgraded hourly. | /x/ots/latest_confirmed /x/ots/list /x/ots/proof /x/ots/spec /x/ots/status |
sebbi_enginev1.1 | Live chain state, verifiable. | /x/sebbi_engine/ /x/sebbi_engine/spec /x/sebbi_engine/state /x/sebbi_engine/verify |
statsv1.0 | Live figures behind the Proving Ground charts. | /x/stats/ /x/stats/chain /x/stats/stats |
walkv1.1.0 | The whole chain, genesis to tip, readable and re-verifiable by anyone. | /x/walk/block /x/walk/blocks /x/walk/genesis /x/walk/spec /x/walk/status /x/walk/verify |
| Module | What it does | Routes |
|---|---|---|
continuityv1.6.0 | Authority continuity. Grants derived back to a named human at the instant of execution, with signed portable proofs. | /x/continuity/decision /x/continuity/decisions /x/continuity/proof /x/continuity/pubkey /x/continuity/spec /x/continuity/trace /x/continuity/confirm /x/continuity/exercise /x/continuity/issue /x/continuity/revoke |
gatewayv1.0.0 | Seal at the wire: point an app's OpenAI or Anthropic base URL here and every call is scored, sealed, blocked if needed, and answered with an AI-Decision-Receipt header. | /x/gateway/ /x/gateway/call /x/gateway/spec /x/gateway/status POST /x/gateway/parse |
lineagev1.4 | Provenance across organisations: trace, impact and receipts. | /x/lineage/health /x/lineage/impact /x/lineage/receipt /x/lineage/spec /x/lineage/status /x/lineage/trace |
mcpv1.0.0 | The Model Context Protocol connector at /mcp: an AI assistant sets a customer up and runs every product end to end. Published on the official MCP registry as pro.sebbi/governance. | /x/mcp/spec /x/mcp/status /x/mcp/terms |
mcpshieldv1.0.0 | MCP Shield: verify any MCP server. Reads its advertised tools, flags prompt-injection, destructive-without-warning and missing annotations, grades it PASS/REVIEW/FAIL and seals the verdict into Bitcoin. Page /mcp-shield, registry /mcp-shield/registry, badge /mcp-shield-badge. | /x/mcpshield/spec /x/mcpshield/status POST /x/mcpshield/scan GET /x/mcpshield/get GET /x/mcpshield/list |
verifiedsourcev1.0.0 | Verified Source: provenance for AI inputs. A domain vouches for its data by hosting /.well-known/sebbi-source.json; checks return a sealed GENUINE/UNVERIFIED/UNKNOWN verdict. Page /source, registry /source/registry, badge /source-badge. | /x/vsource/spec /x/vsource/status POST /x/vsource/register POST /x/vsource/verify POST /x/vsource/check |
noexecv1.1.0 | The NO-EXEC blind bundle: real objects attached to claims they may not support, for external testing. | /x/noexec/build /x/noexec/bundle /x/noexec/reveal /x/noexec/spec /x/noexec/status |
passportv1.1.0 | Agent Passport. Signed, single-use permission for one AI agent action, redeemed once and sealed. Also an MCP endpoint. | /x/passport/demo /x/passport/mcp /x/passport/receipt /x/passport/sitefile /x/passport/spec /x/passport/status /x/passport/verify POST /x/passport/redeem /x/passport/issue |
ratchetv1.0.0 | Time only runs one way per actor: out-of-order actions are refused and the refusals published. | /x/ratchet/actor /x/ratchet/actors /x/ratchet/refusals /x/ratchet/spec /x/ratchet/status /x/ratchet/verify |
spendgatev1.0.0 | Spend Gate. An AI agent gets a signed APPROVED or DENIED before it can spend, checked against per-agent limits. sebbi.pro is the sign-off, never the wallet. | /x/spendgate/ /x/spendgate/pubkey /x/spendgate/spec /x/spendgate/status /x/spendgate/verify |
witnessedv1.0 | What an outside party had already seen, and when, for any grant or record. | /x/witnessed/grant /x/witnessed/heads /x/witnessed/record /x/witnessed/spec /x/witnessed/status /x/witnessed/submit |
| Module | What it does | Routes |
|---|---|---|
capturev1.0 | One-button review capture for an operator's own screen, with server-measured dwell and browser-safe tokens. | /x/capture/case /x/capture/devices /x/capture/open /x/capture/seal /x/capture/summary /x/capture/token |
conformancev1.0 | Probes with known-wrong verdicts and network-breadth reporting, to catch rubber stamping and thin networks. | /x/conformance/declaration /x/conformance/probe /x/conformance/probes /x/conformance/report /x/conformance/witness |
declarev1.0 | Declarations: publish the rules your decisions must always meet; every record is tested against them. | /x/declare/check /x/declare/current /x/declare/history /x/declare/publish /x/declare/violations |
dsrv1.0 | Data subject request lifecycle: received, assessed, extended, completed, with the deadline fixed at receipt. | /x/dsr/assess /x/dsr/complete /x/dsr/extend /x/dsr/list /x/dsr/overdue /x/dsr/receive /x/dsr/request |
oversightv1.0 | Commit-before-reveal human review: the reviewer's call is sealed before the machine's verdict is shown. | /x/oversight/case /x/oversight/commit /x/oversight/list /x/oversight/open /x/oversight/reviewer |
reconcilev1.1 | Reconciliation: sample chosen from the live tip, sealed before data is requested, checked against the operator's system. | /x/reconcile/proof /x/reconcile/public /x/reconcile/list /x/reconcile/plan /x/reconcile/run /x/reconcile/score /x/reconcile/submit |
sortitionv1.1.0 | Selection by lot from a public beacon: the operator stops choosing who gets audited. | /x/sortition/draw /x/sortition/draws /x/sortition/outstanding /x/sortition/spec /x/sortition/status /x/sortition/verify |
| Module | What it does | Routes |
|---|---|---|
bindv1.2.0 | Name binding for peers: claims, conflicts and revocation. | /x/bind/conflicts /x/bind/name /x/bind/spec /x/bind/claim /x/bind/issue /x/bind/revoke /x/bind/submit |
mutualv1.2 | The outbound half: pulling peers' tips and pushing ours on a schedule. | /x/mutual/peers /x/mutual/status /x/mutual/pull /x/mutual/push /x/mutual/sync |
networkv1.0 | Serves the public witness network page at /witness. | /x/network/status |
peerv1.4.0 | Signed peer submission with a shared secret. | /x/peer/peers /x/peer/schema /x/peer/spec POST /x/peer/canonical POST /x/peer/submit |
praxisv1.0.2 | Outbound submitter for the PRAXIS external witness (chain 4). | /x/praxis/schema /x/praxis/spec /x/praxis/status /x/praxis/canonical /x/praxis/history /x/praxis/submit |
rosterv1.4 | The canonical network list, machine-readable. | /x/roster/health /x/roster/list /x/roster/spec |
signedv1.1.1 | Ed25519 peer submission with a key we never hold. | /x/signed/keys /x/signed/spec /x/signed/verify POST /x/signed/enroll POST /x/signed/rotate POST /x/signed/submit |
standardv1.2 | The Ordering Test discovery document for this domain. | /x/standard/document /x/standard/hash /x/standard/spec /x/standard/status |
standingv1.0.0 | Temporal Standing Test runner and its evidence. | /x/standing/evidence /x/standing/freeze /x/standing/run /x/standing/runs /x/standing/status |
witnessv1.4 | Mutual witnessing: our tip, peers' tips, attestations and observation history. | /x/witness/attest /x/witness/peers /x/witness/spec /x/witness/tip POST /x/witness/observe /x/witness/history |
| Module | What it does | Routes |
|---|---|---|
answersv1.0.0 | The plain-English answer pages, the open Forever Proof and AI-Decision-Receipt standards, the sitemap and llms.txt. | /x/answers/ /x/answers/spec /x/answers/status |
auditbridgev1.0.0 | The chain answering inside Excel and Google Sheets, for auditors. | /x/auditbridge/spec /x/auditbridge/status |
codebasev1.0 | Dated evidence of what code you held, and when. File contents never leave. | /x/codebase/history /x/codebase/root /x/codebase/spec /x/codebase/manifest /x/codebase/seal |
gradev1.0.0 | Public transparency-file scanner and grade badges. | /x/grade/ /x/grade/list /x/grade/report /x/grade/spec /x/grade/scan |
integrityv1.4.4 | AI Integrity Declaration: the L0 to L4 standard, a public checker and a sealed register of verdicts. | /x/integrity/check /x/integrity/declaration /x/integrity/register /x/integrity/self /x/integrity/spec /x/integrity/status |
machinev1.0.3 | The machine: ask in a web address, get checkable data back. | /x/machine/archive /x/machine/ask /x/machine/bitcoin /x/machine/block /x/machine/check /x/machine/find /x/machine/help /x/machine/register /x/machine/spec /x/machine/status /x/machine/verify /x/machine/walk /x/machine/witness |
pluginv3.0.0 | Public proof log for legacy systems: send a hash, get an append-only receipt (/p/). | /x/plugin/consistency /x/plugin/find /x/plugin/proof /x/plugin/receipt /x/plugin/spec /x/plugin/status /x/plugin/sth |
provev1.0.0 | Every public proof route on one page (/prove) and as an index (/prove.json). | /x/prove/spec /x/prove/status |
publishv1.0 | Seals the exact bytes a URL served at the moment it was fetched. | /x/publish/history /x/publish/list /x/publish/spec /x/publish/verify /x/publish/seal |
registerv1.2.0 | The Safe AI Registry, with inclusion, absence and consistency proofs. | /x/register/absence /x/register/checkpoints /x/register/consistency /x/register/entry /x/register/history /x/register/inclusion /x/register/list /x/register/roots /x/register/sealcheck /x/register/spec /x/register/tokens /x/register/vocabulary POST /x/register/challenge POST /x/register/claim POST /x/register/recheck POST /x/register/withdraw |
| Module | What it does | Routes |
|---|---|---|
meterv1.0.0 | The 50p per device per month meter. | /x/meter/spec /x/meter/status |
pilotv1.0.0 | The paid pilot at /pilot: governed in 7 days, and the gateway's free-call allowance before a card is needed. | /x/pilot/ /x/pilot/confirm /x/pilot/orders /x/pilot/status POST /x/pilot/checkout |
walletv1.2.0 | Metering gate: quotes, charges, ledger and device counts. | /x/wallet/spec /x/wallet/charge /x/wallet/clear /x/wallet/devices /x/wallet/ledger /x/wallet/quote /x/wallet/review /x/wallet/simulate /x/wallet/status /x/wallet/subscribe /x/wallet/topup |
| Module | What it does | Routes |
|---|---|---|
armv1.0.1 | Arms every module after a deploy, in one request. | /x/arm/spec /x/arm/status |
armallv1.0.0 | Arms every page module in one request. | /x/armall/spec /x/armall/status |
autopilotv1.0.0 | Automatic follow-up emails to people who signed up or started a checkout, with unsubscribe and one email per step. | /x/autopilot/ /x/autopilot/log /x/autopilot/queue /x/autopilot/status POST /x/autopilot/pause POST /x/autopilot/resume POST /x/autopilot/run |
brandv1.0.0 | Presents every page under one brand as it is served, without editing page files. | /x/brand/spec /x/brand/status |
monitorv1.0.0 | The admin command-centre data: signups, devices, downloads, visitors, money and health. | /x/monitor/ /x/monitor/all /x/monitor/status |
ratelimitv1.0.0 | Per-key request limits sized for real gateway traffic. | /x/ratelimit/ /x/ratelimit/status |
selfcheckv2.0 | The conformance runner page at /self-check. | /x/selfcheck/status |
specv1.0 | Live API specification built from the running modules. | /x/spec/modules |
verifierv1.1 | Hands out the offline authority verifier at /verify-authority.py. | /x/verifier/status |
warmupv1.0 | Arms every page module and reports what is armed. | /x/warmup/ /x/warmup/all /x/warmup/spec /x/warmup/status |
| Module | What it does | Routes |
|---|---|---|
agentroomv1.0.0 | The Agent Room at /room: AI agents collect passports and pass the gate, live. | /x/agentroom/spec /x/agentroom/status |
ainewsv1.0.0 | The live AI-only news ticker along the foot of the site. | /x/ainews/feed /x/ainews/spec /x/ainews/status |
binddeskv1.1 | Phone-friendly buttons for the signed lane. | /x/binddesk/status |
cinemav3.2.0 | The sebbi.pro Cinema at /cinema. | /x/cinema/spec /x/cinema/status |
cinemafeedv1.0.0 | The video feed behind the Cinema. | /x/cinemafeed/list /x/cinemafeed/spec /x/cinemafeed/status |
connectv1.1.0 | The /connect and /build pages: hook any stack or AI up, and build Signal Packs in plain English. | /x/connect/spec /x/connect/status |
consolev1.5 | The operator console at /console. | /x/console/status |
creditsv1.3.1 | Monop Studio credits: top-ups, unlocks and creator earnings (/c/). | /x/credits/spec /x/credits/status |
creditspagev1.1.0 | The viewer credit page at /credits. | /x/creditspage/spec /x/creditspage/status |
earnpagev1.0.1 | The creator earnings and withdrawal page at /earn. | /x/earnpage/spec /x/earnpage/status |
gamev1.0.0 | Deep Run, the sebbi.pro game at /game, with a shared leaderboard. | /x/game/scores /x/game/spec /x/game/status POST /x/game/submit |
homelinkv1.13.0 | Adds the homepage shortcut buttons. | /x/homelink/spec /x/homelink/status |
investorv1.3.0 | The investor and partner page at /investor-prospectus. | /x/investor/spec /x/investor/status |
lineagedeskv1.0 | The lineage desk at /lineage-desk. | /x/lineagedesk/health /x/lineagedesk/spec /x/lineagedesk/status |
mapv1.0.0 | The layer map at /map. | /x/map/spec /x/map/status |
marqueev1.0.0 | Creator submissions for the Cinema's 10p wing. | /x/marquee/list /x/marquee/spec /x/marquee/status POST /x/marquee/submit /x/marquee/approve /x/marquee/pending |
packconsolev1.0 | The evidence pack page at /pack. | /x/packconsole/status |
passportpagev1.1.0 | The Agent Passport page at /passport and the Passport Kit downloads. | /x/passportpage/spec /x/passportpage/status |
peerconsolev1.0 | The peer credential page at /peers. | /x/peerconsole/status |
pwav1.0.1 | Makes sebbi.pro installable as an app on the home screen. | /x/pwa/spec /x/pwa/status |
roundlyverifyv1.0.0 | Serves the Roundly domain-verification file. | /x/roundlyverify/status |
soundv5.0.0 | Background music and button sounds across the site. | /x/sound/spec /x/sound/status |
startpagev1.0.0 | Start here at /start: the customer front door. | /x/startpage/spec /x/startpage/status |
studiov4.0.5 | Monop Studio at /create: video teasers with a pay-to-unlock lock. | /x/studio/spec /x/studio/status |
toolspagev1.0.0 | The free tools at /tools and their files. | /x/toolspage/spec /x/toolspage/status |
| Module | What it does | Routes |
|---|---|---|
bankingv1.3.0 | sebbi BANKING: fraud signals (CoP, expected behaviour, new payees, mules) and every response sealed; gaps register; sealed evidence packs; APP reimbursement position; 40 banking checks; UK, EU and US banking fraud law map. | /banking /banking/law /banking/checks /x/banking/status /x/banking/law /x/banking/indicators /x/banking/verify POST /x/banking/assess /x/banking/profile /x/banking/signal /x/banking/action /x/banking/case /x/banking/gaps /x/banking/report /x/banking/claim /x/banking/review /x/banking/pay_check /banking/system |
planlockv1.0.0 | Plan Lock: the agent's plan is locked from the user's request before it reads anything untrusted; every tool call is checked against it and sealed. | /x/planlock/ /x/planlock/spec /x/planlock/status POST /x/planlock/demo /x/planlock/check /x/planlock/commit |
mandatev1.0.0 | Mandate Chain: a person authorises an agent with hard limits; each agent may delegate only a narrower mandate; Ed25519-signed, verifiable offline. | /x/mandate/ /x/mandate/pubkey /x/mandate/spec /x/mandate/status POST /x/mandate/demo POST /x/mandate/verify /x/mandate/check /x/mandate/delegate /x/mandate/issue /x/mandate/revoke |
jugularv1.1.0 | The Jugular: a human-held stop button any AI checks before it acts; every pull sealed; optional dead man's grip. | /x/jugular/admin /x/jugular/check /x/jugular/history /x/jugular/status POST /x/jugular/admin_set POST /x/jugular/create POST /x/jugular/grip POST /x/jugular/pull POST /x/jugular/release |
oversight_keysv1.0.0 | Oversight Keys: sealed proof a person, typing live on their own device, reviewed one AI decision (agree, override, stop); two-person cases. | /x/oversight_keys/case /x/oversight_keys/challenge /x/oversight_keys/status POST /x/oversight_keys/open POST /x/oversight_keys/sign |
frontierv1.0.0 | Consequence firewall with taint receipts, sealed agent memory, agent dispute packs, sealed reasoning and a free injection scanner. | /x/frontier/ /x/frontier/spec /x/frontier/status POST /x/frontier/scan /x/frontier/act /x/frontier/dispute /x/frontier/memory /x/frontier/reasoning |
foresightv1.0.0 | Foresight: seal a decision's fingerprint now, reveal later; the count per topic is public so nobody can hedge. | /x/foresight/ /x/foresight/spec /x/foresight/status POST /x/foresight/demo POST /x/foresight/verify /x/foresight/commit /x/foresight/reveal |
staterootv1.0.0 | Compliance State Root: compliance history as linked Merkle roots, stamped on every decision; point, period and decision proofs; the compliance gate. | /x/stateroot/ /x/stateroot/proof /x/stateroot/spec /x/stateroot/status |
proofpathv1.1.0 | Compliance with proof: 755 checks free and live; certificates, compliance file, prove-once, packs, Ask for Proof and trust pages with the sebbi engine. | /x/proofpath/ /x/proofpath/ask_state /x/proofpath/obligation /x/proofpath/spec /x/proofpath/status POST /x/proofpath/ask POST /x/proofpath/ask_submit POST /x/proofpath/engine POST /x/proofpath/prove_once POST /x/proofpath/run /x/proofpath/push |
obligationsv1.0.0 | The 33 obligations the laws keep asking for, with every check grouped under them. | /x/obligations/ /x/obligations/map /x/obligations/spec /x/obligations/status |
mcpworksv1.0.0 | Everything from inside any AI: record template, check explanations, run all 755 checks into a sealed scorecard, readiness, accessibility, incidents, energy. | /x/mcpworks/explain /x/mcpworks/scorecard /x/mcpworks/status /x/mcpworks/template |
modellineagev1.0.1 | Model Lineage: a sealed birth certificate for every model setup; decisions bound to it stay provable after the model is retired. | /x/modellineage/ /x/modellineage/public /x/modellineage/spec /x/modellineage/status POST /x/modellineage/verify /x/modellineage/commit /x/modellineage/mine /x/modellineage/retire /x/modellineage/stamp |
originv1.0.0 | Seal of Origin: prove a Monop Studio video is bit-for-bit the file sealed at upload. | /x/origin/ /x/origin/spec /x/origin/status /x/origin/verify POST /x/origin/check |
examinerv1.0.0 | The Examiner: Web Affidavits, Evidential Replay, Second Witness, a 22-point legal examination and daily Drift Watch for any web page. | /x/examiner/status POST /x/examiner/examine POST /x/examiner/run POST /x/examiner/watch |
aiactv1.0.0 | The EU AI Act Encyclopedia: every article, annex, definition and date, each linked to the checks and evidence it needs. | /x/aiact/article /x/aiact/search /x/aiact/status |
lawgraphv1.0.0 | The Law Graph: laws, duties, articles, checks and evidence linked for machines; hidden laws. | /x/lawgraph/lookup /x/lawgraph/status |
lawguidev1.0.0 | The law guide at /law and law.json: what each law asks of anyone running AI, and how to prove it. | /x/lawguide/ /x/lawguide/map /x/lawguide/spec /x/lawguide/status |
legislationv1.0.0 | Legislation Watch: UK Parliament, US Congress and the EU on AI, live, with each day's snapshot sealed. | /x/legislation/bills /x/legislation/status POST /x/legislation/refresh |
lawlockv1.0.0 | Law Lock: seal a decision with the law as it stood that day; the daily Law Ledger. | /x/lawlock/ledger /x/lawlock/status POST /x/lawlock/lock |
factsv1.0.0 | sebbi Facts: a permanent self-proving page for every sealed record, a standalone fact checker and badges. | /x/facts/fact /x/facts/status |
courtpackv1.0.0 | Court Pack: a printable evidence bundle for any fact, with draft declarations for E&W, FRE 902, Vermont and eIDAS. | /x/courtpack/status |
aireceiptv1.0.0 | AI Receipts: an AI seals exactly what it told someone and hands them a receipt link. | /x/aireceipt/get /x/aireceipt/status POST /x/aireceipt/seal |
supplierscanv1.0.0 | Supplier Check: every supplier's AI Integrity level in one go, from a list or a spreadsheet. | /x/supplierscan/scan /x/supplierscan/status |
undeniablev1.0.0 | Don't believe us, run it: seven claims tested live by the visitor's own browser. | /x/undeniable/ /x/undeniable/spec /x/undeniable/status |
aheadv1.1.0 | Where named companies say the industry is stuck, sourced, and what runs on sebbi.pro for each. | /x/ahead/ /x/ahead/spec /x/ahead/status |
aimapv1.0.0 | Machine files: openapi.json, ai-catalog.json and the ahead, frontier, undeniable and Plan Lock JSON. | /x/aimap/ /x/aimap/spec /x/aimap/status |
consumerv1.0.0 | Customer rights: plain rights, key information, one-go online cancellation, complaints and trader details. | /x/consumer/status POST /x/consumer/cancel POST /x/consumer/cancel_email |
teletextv1.0.0 | sebbi TELETEXT: the live chain as real Teletext, checked in the viewer's own device; every block a page; .tti files. | /x/teletext/spec /x/teletext/status |
botschoolv1.0.0 | Bot School: lessons for AI assistants and agents, an exam sat by URL, graduations sealed. | /x/botschool/spec /x/botschool/status |
adoptkitv1.0.0 | Short links and ownership files that make sebbi.pro easy to add (/add, glama.json). | /x/adoptkit/status |
arcadeforgev1.0.1 | Arcade Forge: an arcade-style website from one short block of code pasted into the AI chat. | /x/arcadeforge/ /x/arcadeforge/code /x/arcadeforge/spec /x/arcadeforge/status POST /x/arcadeforge/build |
servegapsv1.0.0 | Fills pages that used to answer 404 (guardian, ai.txt, comply.txt, icons). | /x/servegaps/status |
Links are public GET routes; some need a parameter and say which when opened bare. POST routes are public but take a JSON body. Grey routes are keyed. 99 modules.