GOVERNED STATE
Law, authority, governance, configuration and policy are not treated as loose metadata but as bound institutional state.
immo.quick separates admission from execution authority. A request must first pass the relevant admission boundary; even successful access does not itself authorize a production effect.
Core places a fail-closed Access Guardian before the governed compliance pipeline. A request that fails a required validation condition does not reach the downstream governance logic.
The Serverless Edition requires a registered client to establish valid attestation before the request reaches the downstream gate path.
Access is not authority. A productive effect requires a valid, current and scope-bound Execution Right and an executable capability.
Claim boundary: only the architecture of the immo.quick Serverless Edition was demonstrably submitted to the BSI on 28 July 2026. Core was not submitted. Submission is not a BSI audit, certification, endorsement or confirmation.

immo.quick Core is an independent infrastructure class within the umbrella category Institutional Trust Infrastructure: Institutional Trust & Causality Infrastructure. Core binds governed legal state, authority, configuration, software provenance, trusted execution, cryptography, time, witnessing and evidence to institutional determinations and makes bound causality independently verifiable.
Not another dashboard. Not another risk score. Infrastructure that binds institutional determinations to the actual governed trust state and its verifiable causality.
Core defines a distinct infrastructure class: institutional trust is treated as a bound, versioned and verifiable state. A determination becomes institutionally defensible only when the legal state, authority, software, trusted execution, time and evidence under which it arose can be reconstructed and verified.
Law, authority, governance, configuration and policy are not treated as loose metadata but as bound institutional state.
Core makes the technical and governance-side cause of a determination traceable within the modeled and bound state.
Proofs can be independently verified without requiring the originating Core database, internal API or a shared symmetric secret.
Institutions can often show that something happened. The harder question is why this exact determination arose at this exact time under this exact institutional state. Core closes that gap.
The public architecture deliberately exposes capability classes, not the implementation recipe. Internal canonicalization, payload construction, policy thresholds, root aggregation and test vectors remain protected.
Authority, rules, configuration and institutional policies form the bound starting state.
Legal and governance logic is executed as a reproducible determination, not a probabilistic recommendation.
Build, software, crypto and trusted-execution state are bound to the determination.
Relevant states are connected into a verifiable technical and governance-side causal chain.
A minimal, purpose-bound proof is compiled from the required institutional state.
External parties can verify the proof against their requirements without running Core itself.
The 14 verbs are not isolated features. They describe the lifecycle of institutional trust: from governance and compute through proof, reassessment and recovery to query, comparison and simulation.
The freeze includes machine-checkable formal specifications, a canonical proof protocol, portable verification and verification provenance. Claims remain deliberately bounded: formal invariants prove the stated system rules, not universal legal or factual truth.
Critical architecture rules are represented as machine-checkable invariants.
Proofs follow a versioned canonical transport and verification model.
Proof verification can occur without the originating Core DB, internal API or shared secret.
The verification act itself can produce provenance and verifiable verification evidence.
Core classifies proofs by the evidence components that are actually closed. Higher assurance does not come from a higher probability score but from more fully bound and verified prerequisites. Exact internal class definitions remain protected system detail.
Deterministic assurance classes with explicit mandatory components. No probabilistic “trust confidence.”
Which bound legal, authority, configuration, build, time, witness and evidence states led to this result?
Which trust component changed between T1 and T2 and which proofs or determinations are affected?
Can an external reviewer independently verify the relevant proof without running the originating system?
How would a controlled mutation of rule, authority, build or trust state affect the result?
What institutional state applied at that time, and can it be reproduced from the bound artifacts?
What minimum evidence subset may be disclosed for the specific verification purpose?
No artificial grand total. Each suite is reported in its own scope. Internal tests are implementation evidence, not third-party certification.
P0–P24 are frozen. The next evidence class must come from independent external review of architecture, protocol, cryptography, canonicalization and verification semantics.
Governed decisions, auditability, supply-chain provenance, cross-institution verification and historical reconstruction.
Verifiable institutional determinations with clear authority, rule, time and evidence binding.
AI may explain or assist, while authority and trust closure remain deterministic and institutionally bound.
Reproducible trust states, recovery/continuity proofs, trusted time and independent witnessing.
Proof query, selective disclosure and portable verification reduce dependence on manual evidence packages.
Governed institutional state and verifiable decision provenance for high-criticality digital transactions.
Core is Institutional Trust & Causality Infrastructure within the umbrella category Institutional Trust Infrastructure and binds institutional determinations to governed state, execution provenance and evidence.
Audit logs show events. Core binds the states and dependencies under which a determination arose and compiles them into verifiable proofs.
No. Core proves bound technical and governance causality within the modeled system. It does not replace judicial or sovereign legal determination.
An external verifier can check the proof without operating the originating Core database or internal API, provided the required verification material is present.
L1–L9 are deterministic assurance classes. Higher classes require more fully bound and verified proof components, not merely a higher probability.
Governed state. Deterministic compute. Trusted execution. Causality. Proof. Independent verification.