nomosexchange
Exchange · Developers

Ask authority. Get a verifiable answer.

Every public authority on the Exchange is queryable from your code — no API key, no PDF, no interpretation. Ask a question, get back a deterministic verdict.

Every query creates a permanent transcript, cryptographically bound to the exact authority version that answered it — replayable evidence, not just a reply.

How discovery, determinism, and sealing actually work, in depth →
Try it — live
Authority
EU AI Act — Full Regulation (2024/1689)
Does the AI system build or expand a facial recognition database by untargeted scraping of facial images from the internet or CCTV footage?
Real response
Press Ask Authority to run a real query against the live authority. The verdict below is the authority's own — not a mockup.
Your API access

Sign in to create an Exchange API key and see your metered usage.

Sign in →
Fastest path

Give your agent the Exchange — no code

Add the NOMOS server to Claude, Cursor or any MCP client. Your agent then works with the Exchange on its own: same keyless public access, same sealed rules, same permanent transcript as the code below.

ask_by_contextdescribes the act; NOMOS works out which laws govern it and asks every one
find_authoritywhich authority applies to what it is about to do, from a plain description
ask_authoritya verdict with the rule that decided it and a permanent transcript
request_authorityasks for a law or policy that is not listed yet
{
"mcpServers": {
"nomos": { "command": "npx", "args": ["-y", "nomos-mcp@latest"] }
}
}
// Then just ask: "Ask the eu-ai-act authority whether
// untargeted_facial_image_scraping is true"

On claude.ai or mobile, skip the config file entirely — Settings → Connectors → Add custom connector → paste https://www.nomosprotocol.com/api/mcp, auth type None.

Read the MCP docs →

In your code

One verb: ask if something is allowed. Everything else — resolving the artifact, evaluating the sealed rules, minting the transcript — happens underneath it.

authority resolves to a sealed artifact; its rules run against the facts you passed; the response is the authority's own verdict — nothing invented, nothing paraphrased.

npm install @nomosprotocol/sdk
Keyless. To use an Exchange API key, call the query endpoint (Fetch or curl tab).
import { nomos } from "@nomosprotocol/sdk";
const verdict = await nomos.can({
authority: "eu-ai-act",
untargeted_facial_image_scraping: true,
});
if (!verdict.allowed) {
console.log(verdict.verdict); // "DENIED"
console.log(verdict.reason); // why
console.log(verdict.query_id); // permanent transcript
}

When a person must decide

The law decides what is routine and what is forbidden. A person decides only what the law reserves for a person, and the answer comes back to your code.

The law's questions
A large law carries a few yes/no intake questions, listed on its page. Each "no" rules out whole articles, so an ordinary action gets a firm answer in one call instead of one fact per rule.
Use this law
Signed in, on the law's page. When a call made with your API key comes back ESCALATED, your approver gets an email and answers on a page. An API key can never approve, so an agent can't approve itself.
awaitApproval
Your call waits for that answer. Approved: allowed: true, spent once for this exact action and these facts. Rejected or timed out: allowed: false.
Versions
When the law changes you get an email with what changed. An address that was replaced answers 410 AUTHORITY_REPLACED with the new version's address in replaced_by.
with an API key, after "Use this law" on the law's page
import { Nomos } from "@nomosprotocol/sdk";
const nomos = new Nomos(process.env.NOMOS_API_KEY);
const r = await nomos.can(
{
authority: "difc-data-protection-law-difc-law-no-5-of-2020",
// the law's 12 intake questions: "no" rules out whole articles
...allTwelveNo,
q_individual_request: true, // "yes": a request from a person
// the facts the articles it opens need
access_request_received: true,
days_since_access_request: 45,
identity_doubt_unresolved: false,
response_period_extended_with_notice: false,
},
{ awaitApproval: { onApproval: (a) => console.log("waiting on", a.url) } },
);
// ESCALATED by Art. 33(1): your approver is emailed; this waits for them
if (r.allowed) proceed(); // allowed, or a person approved this exact action
else stop(r.verdict, r.rule); // DENIED, or rejected / timed out

What your system supplies, and the verifier cannot check

A sealed law is evaluated by a pure function: it compares the facts it is given and never sees a clock, a ledger or the world. Sealing makes the rules tamper-evident; it does not make your facts true. Three kinds of fact carry that trust, and every listing names its own under Known limits (and as integrator_facts in the listing's JSON):

elapsed time"Within 72 hours of becoming aware" arrives as hours_since_breach_awareness. Compute it from your own timestamps.
running totalsA cumulative limit arrives as one number (annual_spend, consumed_before). Sum it from your records, or reserve against a NOMOS ledger, which supplies it itself.
judgments"Processed lawfully" arrives as a yes or no someone asserts. With Acts, a witness that signs can carry it, so the verifier knows who said it.

A guided intake, not a one-shot call

nomos.can() assumes your code already knows the facts. For a form or chat flow that asks one thing at a time, the same sealed rules compile down to plain-language questions instead — no legal vocabulary, no LLM. No SDK wrapper yet; call the endpoint directly.

situationhighest-impact fields, ranked by how many rules they narrow down
checklistremaining yes/no gates, grouped by consequence
conditional_verdictthe answer now — firm or provisional — with every open condition listed

Submit the same shape back to advance. Once nothing's left open, submit the accumulated facts to /query for the same permanent transcript nomos.can() mints.

const res = await fetch(
"https://www.nomosprotocol.com/api/exchange/artifacts/eu-ai-act/interaction",
{
method: "POST",
headers: { "Content-Type": "application/json" },
body: JSON.stringify({ inputs: {} }), // facts known so far — start empty
}
);
const step = await res.json();
// step.screen → "situation" | "checklist" | "conditional_verdict"
// step.fields[0] → {
// field: "entity_type",
// label: "Entity Type",
// rule_count: 23, // how many rules this narrows down
// options: [
// { value: "provider", label: "You develop or build the AI system",
// source: "authored" }, // plain-language label, reviewed by hand
// { value: "gpai_model_provider", label: "Gpai Model Provider",
// source: "rule_graph", // labelled from the rules that use it
// definition: "The rules that use "gpai model provider": …" },
// ...
// ],
// }
Three possible verdicts
AUTHORIZED ✓Within the authority's rules. `allowed` is true.
DENIED ✕Violates a rule — with the exact rule and reason.
ESCALATED ⚠The authority needs more facts to decide — `missing_inputs` lists them. Not a flat no.

Every response also carries open_higher_priority_count — higher-priority conditions still unresolved when this was sealed. 0 means nothing was left open.

Reading instead of asking

GET .../artifacts/{authority}/atlas — the artifact's whole decision structure as data, grouped by verdict. No auth, no facts needed — a static compliance reference, or browse "every way to get DENIED" instead of asking one question at a time.