Skip to main content

Arca Suite Slice 0: "Don't trust Arca. Check it." — First End-to-End Run Verified by an External Observer

The whole point of a governance platform is that you don't have to believe its vendor. For Slice 0, we ran the first end-to-end test of Arca Suite and had an external observer verify every inference in the answer — without trusting a single line of our code. This post documents what shipped, what was verified, and what we deliberately do not claim.

Key Takeaways

  • First verified end-to-end run: six ordeals (E1–E6), from a deliberately mundane business question — can the crm.clients_eu dataset feed the marketing_2026 campaign? — to a fully re-derived answer.
  • Forgery refused: orphan claims, smuggled house rules, tampered digests — every forged artifact submitted to the platform was rejected with a named rule. exit 1, not a warning.
  • Cold re-verification is mechanical: drift the ontology by one triple and the touched certificate goes superseded while the others stay valid — re-verified cold, by construction, not by a human re-checking.
  • Truth ≠ authority ≠ permission: the compatibility claim was true under our house rule — and the campaign still ships as requires_approval. The three stay separated by construction.
  • Claim format C9.1: three orthogonal status axes; dual formal checkers (Lean 4 + an independent Python implementation, cross-validated); hash-chained decisions with version pinning; replayable measurements.
  • Replayable receipts: 36 captured raw artifacts, a sealed manifest, and an observer script that re-derives everything from live endpoints.

What "Slice 0" means

Arca Suite is built on a simple doctrine: propose, decide, prove. The AI proposes, a named human authority decides, and the platform produces the proof as a by-product of normal operation — not as an after-the-fact audit. Slice 0 is the first slice of that doctrine exercised from end to end: one governed scenario, run on real infrastructure, with every inference in the final answer re-derived by an observer that treats our code as untrusted.

The scenario is an acceptance contract: an explicitly constructed business situation, instantiated on real infrastructure. We say this plainly because the honesty of the claim matters more than its shine.

The six ordeals

An ordeal is a test where the expected outcome is the hard one. If the platform had taken any shortcut, the run would have failed loudly:

  • E1 — Refused falsification. We submitted forged artifacts — orphan claims with no issuer chain, a house rule smuggled into the context, a tampered digest. Each was refused with a named rule. No silent degradation: exit 1.
  • E2 — Cold re-verification of certificates. The ontology was drifted by one triple. The touched certificate transitioned to superseded; the eleven others stayed valid. The re-verification at this step is mechanical — human arbitrations (the design decisions) exist upstream, but this loop needs none.
  • E3 — Truth / authority / permission separation. The dataset-to-campaign compatibility claim was true — under our house rule. Truth did not confer authority, and authority did not confer permission: the support use-case is authorized, the campaign remains requires_approval.
  • E4 — An "opinion" claim can never earn a certificate. The AI proposed a mapping between the marketing process and the GDPR treatment; it failed certification. That is the designed path, not a bug: opinions are checked against rules, certificates are issued only for what rules can bind.
  • E5/E6 — Replayable measurements. Every measurement in the run can be replayed from captured artifacts and live endpoints, by the observer script, without us in the loop.

Under the hood: the verification machinery

  • Claim format C9.1 — every claim carries three orthogonal status axes, so "true", "authorized" and "permitted" can never be collapsed into one score.
  • Dual checker — a Lean 4 formal checker and an independent Python implementation cross-validate each other; a disagreement is itself a verdict.
  • Hash-chained decisions — decisions are appended to a hash chain with version pinning: history cannot be rewritten without detection.
  • Gate decide-then-generate — in production, no content is generated before the decision is sealed: generation is downstream of governance, never upstream.

What shipped, version by version

  • arcaq-api — main @ 15bd41ca, kernel V1+V2 deployed.
  • arca-decision-room — 0.3.x.
  • arca-shield — 0.2.0.
  • Arca Suite — Slice 0 (2026-11-09), this release.

What we do not claim

  • No third-party certification badge: nothing here is "certified" by an external body — it is verifiable, which we hold to be stronger.
  • No "production data discovered": the scenario was constructed as an acceptance contract, run on real infrastructure.
  • No "no humans in the loop" for arbitration: human decisions are part of the design; what is mechanical is the cold re-verification.

Every proof is raw and replayable: 36 captured artifacts, a sealed manifest, an observer script that re-derives everything from live endpoints. Don't trust this post either — check the receipts.

Availability & what's next

Slice 0 is the baseline the rest of the roadmap is measured against. The same release mechanic — end-to-end green, documentation, sites updated in the same cycle — will ship every future slice, with the version marker moving each time.

Explore the platform: What is ArcaQ, Decision Intelligence, Operational Ontology Contracts, and Explainability.