Observability

Simulated fleet, real software.

The KWAM observability server, an NMS plus a live HUD, shows fleet health, replica census, and a heal/event stream. The chunking, coding, heal and integrity logic is real; the fleet is simulated and labeled as such; and the only real bytes are SHA-gated Reed–Solomon fragments.

Request a license See the architecture
Fleet: LIVE vs MODELED Codec round-trips: real bytes Stdlib-only event ring
The HUD

A live dashboard: honest about what is modeled

A Docker observability server serves the HUD over an mTLS-protected port.

It shows fleet health, replica census, a heal / event stream, a Cosmic-Risk panel, JHMM state, and an upload-a-.py demo that erasure-codes the bytes: stored and integrity-verified, never executed.

Fleet health Replica census Heal / event stream Cosmic-Risk panel JHMM state

HUD telemetry line

Labeled at the source

simulated:true · source:MODELED · real_bytes:true

Telemetry carries simulated:true, source:"MODELED". A verified codec round-trip — and only that — carries real_bytes:true.

Modeled vs real

One line, two truths that never blur

Modeled SEU (single-event-upset) pressure is clearly labeled MODELED and never touches a real or reconstructed byte. The label travels with every record, so a reader always knows whether they are looking at a model or a measurement.

Simulated fleet, real software The fleet is simulated and labeled: every telemetry record stamps simulated:true / source:MODELED. The chunking, coding, heal and integrity logic that runs underneath is real, and the only real bytes are SHA-gated Reed–Solomon fragments carrying real_bytes:true. We do not dress a model up as a measurement.
LIVE vs MODELED The boundary sharpened. Real clients, real bytes, real codec round-trips, and real hardware reads are now labeled LIVE; modeled scale and any fleet beyond what is actually connected stay MODELED; and anything KWAM cannot actually read is reported honestly as unavailable, never invented.
Measured integrity, with its math shown Alongside the six-nines design target, KWAM now reports a measured recovery / integrity rate drawn from genuine round-trips, carried with its sample size and a 95% confidence interval (and a rule-of-three bound when there are zero observed failures). The measured number is decimals-with-a-CI from real trials, not a nines claim; the six nines remains a separate design target. The two are never blended into one figure.
Subsystems

The resilience-event and narration layer

A structured event ring, a verified-only frame with an enforced narrator, and an operator-facing report.

KWAM_LOG

A fail-safe, stdlib-only ring of structured resilience events with RFC-5424 severities. Every record stamps simulated:true / source:MODELED; real_bytes appears only on a verified codec round-trip.

KWAM_FRAME / KWAM_FRAMER

A verified-only open frame, verified ∧ real_bytes, with an advisory narrator whose output is enforced: no fabricated number, directive, superlative, or self-preservation framing. Deterministic-primary, fail-closed.

KWAM_REPORT

An operator-facing, downloadable HTML Data-Resiliency report you can hand to a reviewer.

The narrator never produces a byte The frame narrator is advisory and bounded; it explains verified state, it does not invent it. No fabricated number, no directive, no superlative, no self-preservation framing; deterministic-primary and fail-closed.
Zero-state

Honest 0s until something is actually protected

Before any payload is protected, the HUD shows honest 0s for activity metrics. Structural fleet facts stay real, and the zero-state view never mutates engine counters. Looking at the dashboard does not invent activity that did not happen.

API surface

Public reads are open; detail is gated

The server exposes a small set of capability-gated, mTLS-protected endpoints for health, state, and reporting. Simulated-fleet reads are open; protect/mutate actions and per-bit metric detail sit behind operator identity.

Public reads vs gated actions Simulated-fleet state, including health, snapshot, the resilience-event ring, narrated frames, and the downloadable report, is available to public reads. Actions that protect, mutate, or switch modes are capability-gated. Metrics are mTLS-gated: aggregate-only on the open surface, with per-bit detail held behind operator identity.
Payload demo

Upload a .py — it is coded, not run

The HUD's upload demo takes a Python file and erasure-codes the bytes. The fragments are stored and integrity-verified; the code is never executed. This is the one place real bytes enter the server, and they carry real_bytes:true.

# upload demo — store + verify, never execute
protect("payload.py")
  chunk  → RS / LRC fragments
  verify → SHA-256 per fragment
  stamp  → real_bytes:true
# the bytes are coded; the code is not run

Watch the math, the fleet, and the bits — honestly labeled

KWAM is proprietary and licensed directly. Ask us for a HUD walkthrough and we'll show you exactly what is modeled and what is measured.

Request a license Read the docs
Legal

Ownership & governing law

KWAM is our intellectual property, grounded in Swiss law.

Intellectual property & governing law

KWAM is the sole and exclusive property of the owners of KWAM.CH

KWAM — its source code, the KWAM language, the JHMM reconstruction orchestrator, the deterministic codec runtime, and all associated AI components — is a proprietary computer program and the sole and exclusive intellectual property of KWAM.CH. As a computer program it is a protected work under the Swiss Federal Act on Copyright and Related Rights (Copyright Act, CopA), and the exclusive rights of use vest in KWAM as employer; it is further protected as a trade secret under the Swiss Federal Act Against Unfair Competition (UCA). KWAM is offered by private licence only. All rights reserved.

CopA (SR 231.1) Art. 2 para. 3 & Art. 17 · UCA (SR 241) Art. 6 · Governed by the laws of Switzerland · Place of jurisdiction: Zürich