Ask the corpus.

You don't read Apeiris — you query it. Every question below maps to a real JSON endpoint, MCP tool, or interactive surface that answers it today. This page doubles as the platform's capability contract: what's answerable now, and — marked honestly — where the reasoning layer is headed.

Today live now Roadmap reasoning / runtime / write-model mcp_tool = a tool on the apeiris-mcp server GET /… = a JSON endpoint · /page/ = an interactive surface

Discovery — “what exists?”

Enumerate the model: domains, controls, frameworks, evidence types, attestations, vocabularies.

What verification domains and controls exist?
describe_corpusorGET /integration/manifest.json
Today
What identity (or any-domain) controls exist?
search_controls·GET /integration/domains/identity-controls-full.json
Today
What frameworks and normative sources are supported?
obligations_for_framework·GET /integration/source_registry.json
Today
What evidence types, vocabularies, and invariants are defined?
describe_corpus·GET /integration/conformance.json
Today
What attestation does each domain emit?
GET /integration/manifest.json(attestation_artifact)
Today
Which ATLAS techniques or standards discuss prompt injection?
search(ATLAS)·query_graph
Today

Relationships — “what connects to what?”

Walk the knowledge graph: control ↔ threat ↔ framework clause ↔ source ↔ vendor.

What is the full neighborhood of this control?
neighborhood_for_control·get_node
Today
Which evidence does this control require?
evidence_for_control
Today
Show every path from prompt injection to runtime supervision.
shortest_path·query_graph
Today
Which controls map to more than one framework?
query_graph·domain JSON frameworks[]
Today
Which controls defend against this ATLAS technique?
map_to_apeiris·mitigations_for_technique
Today

Coverage — “what am I missing?”

The differentiator. Gaps, thin coverage, and the smallest control set that satisfies an obligation.

Given my stack, which controls am I likely missing?
/advisor/·GET /integration/gapmap.json
Today
Where are the corpus's assurance gaps and thin spots?
find_gaps
Today
What is the minimal control set for this framework or threat?
minimal_control_set
Today
Which obligations are unsupported, single-source, or asserted-only?
find_gaps·proof_for_obligation
Today
How strong is a framework's coverage, obligation by obligation?
/integration/proof/·GET /integration/proofmap.json
Today

Provenance — “where did this come from?”

Few systems answer these well. Every control and mapping carries its source, fit, basis, and currency.

Why does this control exist — its full attack→evidence→obligation chain?
explain_control
Today
Which source supports this control, and when was it last verified?
source_info·GET /integration/source_currency.json
Today
Is this mapping normative or informative — satisfies, equivalent, defends, or informs?
domain JSON frameworks[].relation / basis
Today
Is this citation anchored to primary text, or asserted?
domain JSON frameworks[].basis·/integration/references/
Today
What changed between corpus releases?
what_changed·GET /integration/changelog.json
Today

Composition — “does it hold together?”

Where Apeiris is unique: obligations resolve to controls, evidence, and two distinct verdicts — coverage vs. evidence. mapped ≠ satisfied.

Which controls address this obligation, and where's the gap?
proof_for_obligation·/prove/
Today
For one action, which domains contribute and what evidence is needed?
/one-action/·proof_for_obligation
Today
Is this obligation covered (mapped) vs. satisfied (by real evidence)?
/prove/coverage_verdict vs evidence_verdict
Today
If I remove this control or source, what downstream breaks?
simulate_failure
Today
Compose a live verdict from my system's real runtime evidence.
the platform layer — evidence graph + signing
Roadmap

Runtime — “what should I collect, and when?”

Each control declares its evidence, whether it's machine-collectable, its machine tests, and when it gates.

What evidence should I collect for this control?
evidence_for_control·GET /integration/evidence_map.json
Today
Which evidence is machine-collectable vs. human or third-party?
GET /integration/evidence_map.json (verification)
Today
What machine tests does this control require?
domain JSON machine_tests[]
Today
Which controls gate at runtime vs. only advise?
search_controls·domain JSON blocking_effect
Today
Which runtime events invalidate an attestation, and what expires?
the platform layer — freshness + runtime gates
Roadmap

Vendors & procurement — “who satisfies what?”

A curated vendor capability map (hand-maintained, re-verified on a cadence). Honest about scope.

Which controls does this vendor's product address?
controls_for_vendor
Today
Which vendors address this capability or control?
vendors_for_capability·vendors_for_control
Today
What incidents does this control help defend against?
incidents_for_control·controls_for_incident
Today
Which attestations should I require from a vendor, by domain?
GET /integration/manifest.json (attestation_artifact)
Today
Generate a vendor due-diligence questionnaire from the required evidence.
compose from evidence_for_control — recipe
Roadmap

Build & integrate — “how do I use it?”

The builder's own questions. The API is the data; the schemas are public and stable.

How do I integrate Apeiris, and which endpoints do I call?
/build/·/docs/·/integration/api/
Today
Which schema represents an evidence artifact or attestation?
evidence.schema.json·/integration/conformance.json
Today
How do I verify an artifact and the signed manifest?
/integration/verify/·validate_corpus
Today
How do I query it all from an agent?
apeiris-mcp·/integration/mcp/
Today
How do I contribute controls, extend a namespace, or add a domain?
the community write-model — signed contributions + federated packs
Roadmap

Explain — “why?”

Deterministic explanations today; natural-language reasoning is the evidence-reasoner SLM — and its generative inputs already ship as data, ready for a local model.

Why does this control exist — the full chain, deterministically?
explain_control
Today
What are the two-sided findings and counterpoints for my stack?
GET /integration/advisor.json·/advisor/
Today
Explain, in prose, why authority or runtime supervision matters.
the evidence-reasoner SLM (inputs ship as data today)
Roadmap
Explain why this evidence is insufficient, or why a verdict changed.
the evidence-reasoner SLM
Roadmap

Product development — “what should my product do?”

For startups building on the corpus: what to collect, automate, and gate.

Which controls should I automate vs. route to a human?
GET /integration/evidence_map.json · domain JSON human_review[]
Today
Which controls are runtime vs. pre-deployment?
domain JSON blocking_effect (blocks-runtime-action / blocks-deployment)
Today
What evidence should my product retain or generate?
evidence_for_control·evidence_map.json
Today
Which attestation should I produce for this domain?
GET /integration/manifest.json · evidence.schema.json
Today

Enterprise architecture — “show me the dependencies.”

Blast radius, chains of trust, and where a human has to be in the loop.

If this control or source fails, what's the blast radius?
simulate_failure·GET /integration/dependency.json
Today
Which domains and controls depend on identity or authority?
query_graph·neighbors
Today
Where is human approval required across the corpus?
search_controls·domain JSON human_review / blocking_effect=requires-review
Today
What is the chain of trust — from signed manifest to artifact?
validate_corpus·/trust/·/integration/verify/
Today
Which evidence is authoritative (anchored to primary text)?
source_info·domain JSON basis=anchored
Today

Research — “how is the field moving?”

The corpus is unusually well suited to cross-framework analysis.

Which controls appear across the most frameworks?
GET /integration/source_xref.json·coverage_matrix.json
Today
Where is control strength thin across the whole corpus?
find_gaps·GET /integration/opportunities.json
Today
How has ATLAS guidance changed between releases?
version_diff(ATLAS)
Today
Explain, in natural language, why these standards disagree.
the evidence-reasoner SLM
Roadmap

Why we mark the roadmap honestly

Every Roadmap question is a real capability we intend to earn, not one we claim. Two things drive them: a local evidence-reasoner SLM (natural-language “explain why,” conflict detection, generated questionnaires) and the platform layer (live runtime evidence, composed verdicts on your own system). Following the same discipline as the rest of the corpus — a supported question is a contract; an unsupported one is an opportunity to enrich the corpus or the reasoning layer.

Start querying.

Everything above is open, signed, and free under CC BY 4.0.

Browse the API & endpoints →Point an agent at the MCPBack to Build on Apeiris