A modern concourse with escalators
DevelopersBuilt for developers. Open by design.

One chain.
Every proof.

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 stack — drag to spin, tap a layer
auto-rotating · tap any panel to jump to its reference
ONE
CHAIN
InstallQuickstartNotaryDecision engineThe chainCompleteness & consistencyReplay & lineageAuthorityExported proofMachine-proof reportWitness networkOrdering testPacksOn-premiseClient librariesFree toolsReceipt header (IETF)Agent safetyCompliance with proofEvidenceMachine filesErrorsRoute index

Install — one line in your language no key to start

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 runOne 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 tracesebbi 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 SDKwrapTools(tools), or give the agent its own tools with sebbiTools() from sebbi/ai-sdk (seal, check, reverse). Guide
CrewAICrew(..., step_callback=step_callback, task_callback=task_callback) from sebbi.integrations.crewai
LangChain / LangGraphconfig={"callbacks": [SebbiCallbackHandler()]} from sebbi.integrations.langchain
OpenAI Agents SDK · MCPsebbi.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 clientPOST /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.
Reversalssebbi.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.

Quickstart — seal something in one call

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
}
Your content never leaves your machine. You hash it locally; only the 64-character fingerprint is sent. The chain proves a document with that exact fingerprint existed at that moment — it never sees the document itself.

Notary — seal a fingerprint of anything no key

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 notary — prove exact text existed

POST /api/post/seal — body {"fingerprint":"<sha256>"}.

GET /api/verify-post?content=<sha256> — returns {"verified":true,"block_index":…,"sealed_at":…,"seal":…}, else {"verified":false}.

Identity notary — prove a profile is the original

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.

Payment notary — stop invoice fraud

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.

Wire it into your stack

# 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.

Decision engine — POST /api/govern POSTBearer key

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
  }'
FieldTypeMeaning
user_idstringYour stable identifier for the acting user. Trust is learned per user_id.
actionstringWhat they're doing — payment, login, message, anything.
amountnumberMonetary value if relevant, else 0. Log-scaled internally.
countrystringISO-style code. Country changes and off-allowlist jurisdictions raise score.
device_idstringDevice identifier for velocity correlation.
anomaly0–1Your behavioural-anomaly signal, if you have one. 0 if not.
device_risk0–1Your 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.

Challenges — the exception workflow is built in

{
  "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.

Try it with no key at all

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/governA real decision through the live engine, sealed into the production chain.
POST /x/demo/reviewOpens a review case with the verdict withheld and a server-measured clock running.
POST /x/demo/commitCommits your call before the machine verdict is revealed.
GET /x/demo/statsAggregates across everyone who has tried it, including how many committed in under two seconds.

The chain — receipts, sequences, inclusion mostly no key

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.

The two failure modes are separate on purpose. Edited records break the chain. Missing records break the sequence. A system that only detects one of those is only half a record.
EndpointReturns
GET /api/verify-chainno 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/coveragekey Reconciliation in one call: receipts issued vs blocks sealed, complete: true/false.
GET /api/pulsekey Your last hour — verdict mix, recent decisions with reasons, chain tip.
GET /api/regulation-mapno key Versioned, hash-sealed map of engine features to legal obligations.
GET /api/specno key This API describing itself, machine-readable.
GET /x/statsno key Public aggregates — chain growth, verdict mix, dwell distribution. Nothing scoped to a customer key.

Anchoring — and what "anchored" actually means here

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/statusno key Proof counts, pending vs confirmed, first attempt date.
GET /x/ots/listno key Every proof on file.
GET /x/ots/proofno key The raw .ots bytes, base64. Verify with the standard opentimestamps client — nothing of ours required.
POST /x/ots/upgradekey Re-fetches proofs from the calendars to confirm them. Also runs hourly on its own.

Completeness and consistency — prove what isn't there no key

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.

complete — inclusion, absence, completeness

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/periodsWhich periods are committed, and how many days after each closed.
GET /x/complete/rootThe 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 · /verifyThe rules, and a checker.
POST /x/complete/commit · /erasekey Only closed periods commit, and each commits once.

consistency — append-only, demonstrated not asserted

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/rootCurrent 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/checkpointkey Seals the current size and root into the chain so it gets anchored.
Two trees, two questions. 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.

Replay and lineage mostly no key

replay — determinism as a black box

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/challengeRun 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/selfReproduction rate across a sample.
GET /x/replay/fingerprintThe code fingerprint of the deployed decision function.
POST /x/replay/check · /attestkey

lineage — provenance across organisations

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/declarekey Records an edge.
Stated plainly: an edge is a dated, non-repudiable claim about what fed a decision. It is not proof the claim is true. The chain fixes when it was said, not whether it was right.

Authority continuity — derive it, don't look it up Bearer key

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.

Issue a root grant

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 }

Delegate it onward

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 acceptance. A grant that only narrows inherits the acceptor above it. A grant that can delegate onward must name its own 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.

Exercise it

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"] }
VerdictMeaning
ALLOWEvery invariant held and the risk engine agreed. Derivable from a valid human grant.
CHALLENGENothing 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.
BLOCKAn invariant failed. The response names the grant and the invariant.
Composition. The verdict is the worse of the authority verdict and the risk engine's. Either can stop an action; neither waves one through alone. If the engine cannot be reached or returns something unreadable, the result degrades to CHALLENGE — a missing risk opinion is missing, not favourable.

Bind the execution to the decision

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"}'

Revoke

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.

EndpointNotes
GET /x/continuity/specno 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.

witnessed — the gap authority cannot close on its own

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 · /statusAccepted peer heads, coverage strength, and the collusion limit stated openly.
POST /x/witnessed/submitkey

Standing conditions — when a fact changes after the decision

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/factkey write a fact in your namespace; every change sealed
POST /x/conditions/attachkey {grant, conditions, reason?}, grant issuer only
GET /x/conditions/checkno key evaluate a grant's conditions now

The exported proof — and a verifier that doesn't need us no key

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).

No dependencies, no network, no telemetry. Python standard library only, including the Ed25519 implementation. It never contacts sebbi.pro and reports nothing back — a verification tool that phones home to the party being verified is not a verification tool. Check script_sha256 at /x/verifier/status against what you downloaded, and read it before you run it.

The refusal proof

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.

The offline verifier for the rest of it

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.pyThe authority verifier, as a plain file.
GET /x/verifier/statusIts size and SHA-256, to check what you downloaded.
GET /x/continuity/pubkeyThe Ed25519 public key, RFC 8032, verifiable with any standard library.
Honest limits. This proves authority was derivable from a human grant — not that the human should have granted it, and not that the parameters describe something that really happened. Grants are authenticated by sealing rather than per-issuer signatures, so an outside party verifies them through the chain rather than entirely offline. The risk half of a composed verdict cannot be re-derived without the scoring engine. And decisions made before signed proofs shipped carry no lineage snapshot — reconstructing one now would describe today's authority rather than the authority the action was judged against, so the route refuses instead.

Machine-proof report — one block, every detail key for the full report

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.

EndpointReturns
GET /x/dossier/report?block=Nkey The full report for a block your key sealed. receipt=<audit hash> works instead of block.
POST /x/dossier/issuekey {"block":N}. Builds the report and seals its digest. Returns the report, the digest and the block it was sealed in.
POST /x/dossier/attachkey 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=Nno 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/specno 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": "…"
}
Personal data never goes into the chain. The chain is append-only, so an IP address written into it could never be erased. Request details are kept in their own table and only their SHA-256 fingerprints are sealed — rolled into a Merkle root every five minutes and sealed as one block. Each report carries the inclusion proof, so the details are tamper-evident without being permanent. Raw details are deleted after two years; the fingerprint stays and the report says so.
Who can open what. Your key opens reports for blocks your key sealed — never anyone else's. The IP captured is the machine that called the API, usually your own server; your end user's address appears when you attach it. Request details are recorded for blocks sealed from 5 October 2026; older blocks are reported as not captured rather than guessed.

The witness network — the part we cannot control no key, ever

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/tipOur current head. A peer cannot seal what it cannot read, so this is public on purpose.
POST /x/witness/observeSubmit 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 · /specWhat was sealed, and the protocol in full.
GET /x/roster/listEvery chain that has submitted, with first-seen dates and elapsed-time status: current, stale, silent.
GET /x/mutual/peers · /statusWho we fetch from, and how the outbound cycle is running.
GET /x/praxis/statusThe signed lane — customer-held Ed25519 keys rather than a shared secret.
GET /x/signed/specThe signed submission contract.
Two non-rejecting checks are sealed alongside every tip. Liveness (confirmed / live / self-declared, via an SSRF-guarded fetch of a submitted URL) and name binding (first-use / bound / conflict / unbound, network-wide). Neither refuses a submission. Both are recorded so a reader can weigh it. And current, stale and silent measure elapsed time only — nothing else.

The Ordering Test no key

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.jsonThe discovery document. base_url is derived from the Host header, so the file publishes whichever domain serves it.
GET /x/standard/status · /hashModule state and the document digest.
GET /self-checkThe 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/specThe Safe AI Registry — self-service listing, absence proofs, RFC 6962 consistency, and revocations that seal rather than delete.

Packs — three different things, one chain

The word does three jobs, so here they are apart.

KindRouteWhat 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.

Cost packs — the library

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 · /statusno key Browse and read every published pack, including its rules and reasons.
POST /x/packs/validate · /publish · /forkno 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/runkey Executing a pack against real traffic is the metered part.

Evidence packs

GET /x/pack/specno key What the pack contains and how each check is performed.
POST /x/pack/preview · /render · /issuekey issue seals the pack's own digest, so the document cannot be edited after the fact.

On-premise — Sebdog runs without us

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.

No phone home. Licensing is an Ed25519 token you hold, validated locally against a published public key — we sign on our server and ship only the public half, so nothing that can mint a licence ever reaches a customer machine. The engine makes no outbound call to sebbi.pro at all, which means it keeps running whether we are up, down or gone.
GET /health · /stats · /snapshotsLocal operational state.
POST /governThe decision, locally. Requires a matching bearer.
GET /verify-chainRewalks and rehashes every block on your own machine.
GET /tipIts head, public on purpose — a peer cannot seal what it cannot read.
POST /witness/observeOpen on purpose. Your on-premise chain can be witnessed by chains you choose.
GET /peersWho 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.

Client libraries and the metering gate

FileWhat 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.pyDrop-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.pyZero-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.pyThe 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.jsBrowser widget using capture tokens rather than API keys, with server-measured dwell.
sebbi_tokensaver.pyThe 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.

The wallet gate

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.

Duplicate receipts halt the key. A receipt presented twice returns 423 and raises a review item — not even a subscribed device passes — until a person clears it. A machine does not get to decide whether a repeated hash was a replay or a collision.
GET /x/wallet/specno key
POST /x/wallet/charge · /quote · /simulatekey 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 · /clearkey

Free tools no key on any route

/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.

AI-Decision-Receipt — the receipt header, now an IETF Internet-Draft read it, no key

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.

Agent safety — plan, authority, stop, oversight

Plan Lock — injected text can't change what the agent does

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.

Mandate Chain — authority that only ever narrows

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.

The Jugular — the stop button

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.

Oversight Keys — proof a person reviewed a decision

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.

Frontier mechanisms

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.

Compliance with proof checks freesealing: sebbi engine, 50p a month

755 checks, obligations and the compliance file

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.

Everything from inside any AI

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.

Compliance State Root

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.

Law Lock

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.

Foresight

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.

Model Lineage

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.

Evidence anyone can check no key

sebbi Facts and Court Packs

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.

AI Receipts

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.

The Examiner

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.

Supplier Check

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.

Seal of Origin

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.

Machine files for AI assistants and crawlers no key

/openapi.jsonOpenAPI 3.1 for the proof, compliance and agent-safety APIs.
/.well-known/ai-catalog.jsonEvery product, page and machine file in one catalogue.
/ai-act.jsonThe EU AI Act Encyclopedia: every article, annex, definition and date.
/law-graph.jsonLaws → duties → articles → checks → evidence, one graph.
/law.jsonWhat each law asks of anyone running AI, and how to prove it.
/legislation.json · /legislation.rssLive AI legislation: UK Parliament, US Congress, EU.
/ahead.json · /frontier.json · /undeniable.jsonWhere the industry says it is stuck; the frontier mechanisms; the public test protocol.
/teletextsebbi TELETEXT. /teletext/<page>.txt plain text, /teletext/data/<page> JSON, /teletext/<page>.tti real Teletext files; /teletext/201/<block> for any block.
/schoolBot 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=.

Errors and router behaviour

StatusBodyMeaning
400valid sha-256 fingerprint requiredNotary needs a 64-char hex fingerprint. Govern needs all seven fields.
401api_key_required / invalid_api_keySend Authorization: Bearer YOUR_KEY. Public routes need none.
403account_inactiveAccount disabled — get in touch.
404unknown_actionRead 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.
409fork evidence / period already committedConsistency found a fork, or a closed period was committed twice.
423review requiredA duplicate receipt halted the key. A person clears it.
429quota_exceeded / rate_limit_minute / rate_limit_hourFree tier spent, or per-key limits: 60/min, 1000/hr.
500internalLogged 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.

Route index generated from the code

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.

Decisions and evidence

ModuleWhat it doesRoutes
counterfactual
v1.0
What would have changed the verdict, computed by inverting the real scoring function./x/counterfactual/decision
/x/counterfactual/explain
/x/counterfactual/probing
demo
v1.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
dossier
v1.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
fingerprint
v1.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
humankeys
v1.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
notary
v1.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
pack
v1.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
packs
v1.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
replay
v1.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
rulebind
v1.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
savings
v1.1
Cost model behind /savings, with a sealed copy of any result./x/savings/status
/x/savings/verify
POST /x/savings/seal
tokensaver
v2.2.0
Token saver platform side: published weights and rules, aggregate stats, receipt checks./x/tokensaver/spec
/x/tokensaver/stats
/x/tokensaver/verify

The chain

ModuleWhat it doesRoutes
archive
v1.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
blocks
v1.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
complete
v1.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
consistency
v1.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
custody
v1.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
disclosure
v1.0.0
The chain reset, put on the record inside the chain./x/disclosure/spec
/x/disclosure/statement
/x/disclosure/status
genesis
v1.0.1
Chain identity: which chain this is, where it started, how to check it./x/genesis/chain
/x/genesis/spec
/x/genesis/status
heartbeat
v1.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
held
v1.0
The tips sebbi.pro holds for other chains./x/held/peers
/x/held/spec
/x/held/status
/x/held/tips
ots
v1.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_engine
v1.1
Live chain state, verifiable./x/sebbi_engine/
/x/sebbi_engine/spec
/x/sebbi_engine/state
/x/sebbi_engine/verify
stats
v1.0
Live figures behind the Proving Ground charts./x/stats/
/x/stats/chain
/x/stats/stats
walk
v1.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

Authority and agents

ModuleWhat it doesRoutes
continuity
v1.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
gateway
v1.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
lineage
v1.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
mcp
v1.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
mcpshield
v1.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
verifiedsource
v1.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
noexec
v1.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
passport
v1.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
ratchet
v1.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
spendgate
v1.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
witnessed
v1.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

Oversight and notaries

ModuleWhat it doesRoutes
capture
v1.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
conformance
v1.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
declare
v1.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
dsr
v1.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
oversight
v1.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
reconcile
v1.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
sortition
v1.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

Witness network

ModuleWhat it doesRoutes
bind
v1.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
mutual
v1.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
network
v1.0
Serves the public witness network page at /witness./x/network/status
peer
v1.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
praxis
v1.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
roster
v1.4
The canonical network list, machine-readable./x/roster/health
/x/roster/list
/x/roster/spec
signed
v1.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
standard
v1.2
The Ordering Test discovery document for this domain./x/standard/document
/x/standard/hash
/x/standard/spec
/x/standard/status
standing
v1.0.0
Temporal Standing Test runner and its evidence./x/standing/evidence
/x/standing/freeze
/x/standing/run
/x/standing/runs
/x/standing/status
witness
v1.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

Registers and standards

ModuleWhat it doesRoutes
answers
v1.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
auditbridge
v1.0.0
The chain answering inside Excel and Google Sheets, for auditors./x/auditbridge/spec
/x/auditbridge/status
codebase
v1.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
grade
v1.0.0
Public transparency-file scanner and grade badges./x/grade/
/x/grade/list
/x/grade/report
/x/grade/spec
/x/grade/scan
integrity
v1.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
machine
v1.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
plugin
v3.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
prove
v1.0.0
Every public proof route on one page (/prove) and as an index (/prove.json)./x/prove/spec
/x/prove/status
publish
v1.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
register
v1.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

Billing

ModuleWhat it doesRoutes
meter
v1.0.0
The 50p per device per month meter./x/meter/spec
/x/meter/status
pilot
v1.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
wallet
v1.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

Operations

ModuleWhat it doesRoutes
arm
v1.0.1
Arms every module after a deploy, in one request./x/arm/spec
/x/arm/status
armall
v1.0.0
Arms every page module in one request./x/armall/spec
/x/armall/status
autopilot
v1.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
brand
v1.0.0
Presents every page under one brand as it is served, without editing page files./x/brand/spec
/x/brand/status
monitor
v1.0.0
The admin command-centre data: signups, devices, downloads, visitors, money and health./x/monitor/
/x/monitor/all
/x/monitor/status
ratelimit
v1.0.0
Per-key request limits sized for real gateway traffic./x/ratelimit/
/x/ratelimit/status
selfcheck
v2.0
The conformance runner page at /self-check./x/selfcheck/status
spec
v1.0
Live API specification built from the running modules./x/spec/modules
verifier
v1.1
Hands out the offline authority verifier at /verify-authority.py./x/verifier/status
warmup
v1.0
Arms every page module and reports what is armed./x/warmup/
/x/warmup/all
/x/warmup/spec
/x/warmup/status

Site pages

ModuleWhat it doesRoutes
agentroom
v1.0.0
The Agent Room at /room: AI agents collect passports and pass the gate, live./x/agentroom/spec
/x/agentroom/status
ainews
v1.0.0
The live AI-only news ticker along the foot of the site./x/ainews/feed
/x/ainews/spec
/x/ainews/status
binddesk
v1.1
Phone-friendly buttons for the signed lane./x/binddesk/status
cinema
v3.2.0
The sebbi.pro Cinema at /cinema./x/cinema/spec
/x/cinema/status
cinemafeed
v1.0.0
The video feed behind the Cinema./x/cinemafeed/list
/x/cinemafeed/spec
/x/cinemafeed/status
connect
v1.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
console
v1.5
The operator console at /console./x/console/status
credits
v1.3.1
Monop Studio credits: top-ups, unlocks and creator earnings (/c/)./x/credits/spec
/x/credits/status
creditspage
v1.1.0
The viewer credit page at /credits./x/creditspage/spec
/x/creditspage/status
earnpage
v1.0.1
The creator earnings and withdrawal page at /earn./x/earnpage/spec
/x/earnpage/status
game
v1.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
homelink
v1.13.0
Adds the homepage shortcut buttons./x/homelink/spec
/x/homelink/status
investor
v1.3.0
The investor and partner page at /investor-prospectus./x/investor/spec
/x/investor/status
lineagedesk
v1.0
The lineage desk at /lineage-desk./x/lineagedesk/health
/x/lineagedesk/spec
/x/lineagedesk/status
map
v1.0.0
The layer map at /map./x/map/spec
/x/map/status
marquee
v1.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
packconsole
v1.0
The evidence pack page at /pack./x/packconsole/status
passportpage
v1.1.0
The Agent Passport page at /passport and the Passport Kit downloads./x/passportpage/spec
/x/passportpage/status
peerconsole
v1.0
The peer credential page at /peers./x/peerconsole/status
pwa
v1.0.1
Makes sebbi.pro installable as an app on the home screen./x/pwa/spec
/x/pwa/status
roundlyverify
v1.0.0
Serves the Roundly domain-verification file./x/roundlyverify/status
sound
v5.0.0
Background music and button sounds across the site./x/sound/spec
/x/sound/status
startpage
v1.0.0
Start here at /start: the customer front door./x/startpage/spec
/x/startpage/status
studio
v4.0.5
Monop Studio at /create: video teasers with a pay-to-unlock lock./x/studio/spec
/x/studio/status
toolspage
v1.0.0
The free tools at /tools and their files./x/toolspage/spec
/x/toolspage/status

Added 24 to 26 October 2026

ModuleWhat it doesRoutes
banking
v1.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
planlock
v1.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
mandate
v1.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
jugular
v1.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_keys
v1.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
frontier
v1.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
foresight
v1.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
stateroot
v1.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
proofpath
v1.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
obligations
v1.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
mcpworks
v1.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
modellineage
v1.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
origin
v1.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
examiner
v1.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
aiact
v1.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
lawgraph
v1.0.0
The Law Graph: laws, duties, articles, checks and evidence linked for machines; hidden laws./x/lawgraph/lookup
/x/lawgraph/status
lawguide
v1.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
legislation
v1.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
lawlock
v1.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
facts
v1.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
courtpack
v1.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
aireceipt
v1.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
supplierscan
v1.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
undeniable
v1.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
ahead
v1.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
aimap
v1.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
consumer
v1.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
teletext
v1.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
botschool
v1.0.0
Bot School: lessons for AI assistants and agents, an exam sat by URL, graduations sealed./x/botschool/spec
/x/botschool/status
adoptkit
v1.0.0
Short links and ownership files that make sebbi.pro easy to add (/add, glama.json)./x/adoptkit/status
arcadeforge
v1.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
servegaps
v1.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.

Kick the tyres without writing code: run a live decision at the Proving Ground, browse the library at sebbi.pro/packs.html, seal a post at sebbi.pro/seal, verify it at sebbi.pro/verify, or run the whole conformance suite yourself at sebbi.pro/self-check. Same maths, same catch.
AI news
The VergeTrump’s latest land grab is an AI hub in the Philippines4mThe VergeWhat’s next for Nvidia? Whatever doesn’t rock the mind-bogglingly profitable boat15mThe DecoderGoogle Deepmind's Project Genie update brings Genie 4, chainable worlds, and a community gallery for remixing18mThe DecoderMicrosoft is replacing outside AI models in its own products with cheaper in-house alternatives57mThe VergeWhat is Nvidia without AI’s sugar daddy in charge?1hArs TechnicaWill Wright's next simulation will use AI to mine content from your memories1hTechCrunchGoogle’s AI feature in Search gets its own incognito mode1hThe DecoderOpenAI says its models delivered a year's worth of chip optimization on top of AMD's own engineering1hThe VergeDisney’s new Star Wars animatronics interact with guests using AI1hWiredInside Nvidia’s First Post-Jensen All-Hands: Pay Raises and More Equity2hTechCrunchMore banks say customers using AI agents are on their own — even if they get hacked2hThe GuardianUS senators urge White House AI chief to fix vulnerabilities after mass outages2hTechCrunchSam Altman warns against a future where AI, not humans, calls the shots2hWiredArtex Is Criminals’ New Favorite ‘Point-and-Shoot’ AI Hacking Tool3hTechCrunchOpenAI CEO Sam Altman says it’s ‘hard to imagine the AI industry without Jensen’3hThe DecoderPangram flags 99 percent of an award-winning Peruvian novel as AI-generated, but the publisher stands by its author3hThe DecoderAnthropic, OpenAI, and Google models readily marked medics, journalists, and surrendering soldiers as kamikaze drone targets3hThe VergeRemember the frontier AI pause? Chip companies don’t either4hWired‘Just Ridiculous’: A Famed Philosopher Takes on AI Consciousness4hMIT Technology ReviewThe AI Hype Index: AI is everywhere5hBBC NewsThe seven Anthropic founders who are about to become multi-billionaires5hBBC NewsHacks, AI or just overdue updates - why have there been so many outages?6hTechCrunchNvidia clarifies when it will — and won’t — keep financing neoclouds6hThe GuardianAria awards: how do Australian artists feel about their music being used to train AI? – video9hThe VergeTrump’s latest land grab is an AI hub in the Philippines4mThe VergeWhat’s next for Nvidia? Whatever doesn’t rock the mind-bogglingly profitable boat15mThe DecoderGoogle Deepmind's Project Genie update brings Genie 4, chainable worlds, and a community gallery for remixing18mThe DecoderMicrosoft is replacing outside AI models in its own products with cheaper in-house alternatives57mThe VergeWhat is Nvidia without AI’s sugar daddy in charge?1hArs TechnicaWill Wright's next simulation will use AI to mine content from your memories1hTechCrunchGoogle’s AI feature in Search gets its own incognito mode1hThe DecoderOpenAI says its models delivered a year's worth of chip optimization on top of AMD's own engineering1hThe VergeDisney’s new Star Wars animatronics interact with guests using AI1hWiredInside Nvidia’s First Post-Jensen All-Hands: Pay Raises and More Equity2hTechCrunchMore banks say customers using AI agents are on their own — even if they get hacked2hThe GuardianUS senators urge White House AI chief to fix vulnerabilities after mass outages2hTechCrunchSam Altman warns against a future where AI, not humans, calls the shots2hWiredArtex Is Criminals’ New Favorite ‘Point-and-Shoot’ AI Hacking Tool3hTechCrunchOpenAI CEO Sam Altman says it’s ‘hard to imagine the AI industry without Jensen’3hThe DecoderPangram flags 99 percent of an award-winning Peruvian novel as AI-generated, but the publisher stands by its author3hThe DecoderAnthropic, OpenAI, and Google models readily marked medics, journalists, and surrendering soldiers as kamikaze drone targets3hThe VergeRemember the frontier AI pause? Chip companies don’t either4hWired‘Just Ridiculous’: A Famed Philosopher Takes on AI Consciousness4hMIT Technology ReviewThe AI Hype Index: AI is everywhere5hBBC NewsThe seven Anthropic founders who are about to become multi-billionaires5hBBC NewsHacks, AI or just overdue updates - why have there been so many outages?6hTechCrunchNvidia clarifies when it will — and won’t — keep financing neoclouds6hThe GuardianAria awards: how do Australian artists feel about their music being used to train AI? – video9h