Frequently asked

The KCN's Dynamic Querying Algorithm (DQA) is designed to operate within bounded latency envelopes regardless of corridor geography. Each capsule corridor maintains a local state cache — a compressed representation of the capsule's current layer position and karma balance — that allows the Actor–Critic–Audience triad to operate on local state without requiring a round-trip to the Global Digital Twin Ledger for every decision cycle.

For cross-border operations, the DQA uses a two-phase commit protocol: the local corridor executes the karma delta, and the Ledger confirmation follows asynchronously within a configurable window (default: 400ms). Capsules operating in the Ethereal and Astral layers tolerate this window without state inconsistency. Cosmic layer operations — which require UBQC verification — have a longer confirmation window and are not latency-sensitive by design.

Sigma Terminal nodes communicate over a QKD-encrypted sovereign fabric. The physical round-trip time between the Americas (Wyoming) and Europe (Zurich) corridors is approximately 80–120ms at the network layer. The UBQC protocol adds a computational overhead of 200–600ms depending on circuit depth — this is the dominant latency factor for Cosmic layer operations, not the network transit time.

Transient Scale corridors (Asia-Pacific, Oceania) operate on a hybrid RL fabric with standard TLS encryption. Round-trip times between these corridors and Sigma Terminal nodes are 40–80ms network + 50–150ms RL inference overhead. The DQA routes Cosmic layer verification requests to the nearest Sigma Terminal node automatically.

Yes — karma continuity is guaranteed by the capsule's local state cache and the Karma Loop's phase-gating mechanism. If a corridor becomes unreachable, the capsule enters a suspended state at its current Karma Loop phase. The Actor continues to observe the environment; the Critic suspends reward propagation; the Audience holds its authority signal.

When the corridor reconnects, the DQA performs a state reconciliation: it replays the suspended observation window against the Ledger's authoritative record and resolves any karma delta that accumulated during the outage. The capsule resumes from its reconciled state. No karma is lost; no phase is skipped. The reconciliation window is bounded by the corridor's configured maximum suspension duration (default: 72 hours).

The KCN uses a hybrid logical clock (HLC) scheme for all karma events. Each corridor maintains a local HLC that advances monotonically and incorporates the maximum observed timestamp from any message received from other corridors. This ensures that karma events are causally ordered even when physical clocks drift.

At the Sigma Terminal tier, QKD-encrypted time synchronization is performed against a sovereign time authority — the same authority that anchors the Global Digital Twin Ledger's block timestamps. Transient Scale corridors synchronize against NTP with a 50ms tolerance. The DQA rejects karma events with timestamps that fall outside the corridor's accepted clock window and flags them for manual review.

A full 9-axis tensor synchronization — updating all nine axes (Substrate, Temporal, Spatial, Relational, Intentional, Karmic, Epistemic, Ontological, Sovereign) simultaneously — requires approximately 12–18ms of CPU time on a Transient Scale node. In practice, most karma events touch only 2–4 axes; the DQA performs partial tensor updates that complete in 2–4ms.

At the Sigma Terminal tier, photonic processors handle tensor routing with near-zero latency for the matrix multiply operations. The bottleneck at Sigma Terminal is the UBQC verification step for Sovereign axis updates, not the tensor computation itself. The 9-axis tensor is designed to be sparse — most axes are stable for long periods, and the DQA only propagates updates to axes that have changed.

The Karma Loop operates on a configurable cycle period — default 100ms for Sandbox, 50ms for Transient Scale, and event-driven (no fixed period) for Sigma Terminal. Each cycle triggers a partial tensor synchronization covering the axes relevant to the current phase.

Phase 1 (Observation) and Phase 2 (Evaluation) are read-only with respect to the Ledger — they consume state but do not write. Phases 3 (Reward Propagation) and 4 (Policy Update) write karma deltas to the local state cache. Phase 5 (Sigma Collapse, when triggered) initiates a full Ledger write with UBQC verification. The synchronization overhead is therefore concentrated in Phases 3–5, and the DQA batches Phase 3–4 writes to reduce Ledger round-trips.

Tier transitions are the highest-overhead operations in the KCN. Moving a capsule from Sandbox to Transient Scale requires a full state migration: the local state cache is serialized, transmitted to the target tier's node, and deserialized. This takes 200–800ms depending on capsule state size.

Transient Scale to Sigma Terminal transitions additionally require a UBQC-verified authority handoff — the Sovereign axis must be re-anchored to the new tier's quantum node. This adds 500ms–2s of UBQC overhead. Tier transitions are therefore scheduled during low-activity windows and are not performed mid-Karma-Loop-cycle. The DQA monitors capsule activity and recommends tier transitions when karma thresholds approach the current tier's ceiling.

Ethereal layer capsules have the lowest synchronization overhead in the system. They operate entirely on classical silicon, use only the Substrate and Temporal axes of the tensor, and do not require Ledger writes for routine karma events — only for phase transitions and Sigma Collapse triggers.

A capsule that remains in the Ethereal layer will accumulate karma deltas in its local state cache indefinitely. The DQA performs a background Ledger reconciliation every 24 hours for Ethereal capsules, batching all accumulated deltas into a single write. This means Ethereal capsules impose near-zero real-time synchronization overhead — the cost is deferred and amortized.

A Sandbox environment requires: a classical CPU/GPU node with at least 512 GB RAM and 10 TB NVMe storage; the KCN runtime package (available via the developer portal); and a local instance of the Dynamic Querying Algorithm daemon.

The KCN runtime ships with a simulated Karma Loop environment — you do not need physical Hardened Substrate or neuromorphic hardware to run Sandbox. The simulated environment supports up to 10⁶ capsules and all five Karma Loop phases. UBQC verification is mocked in Sandbox — the Sovereign axis is populated with deterministic test values rather than real quantum computation. This is sufficient for developing and testing capsule lifecycle logic, karma delta calculations, and DQA routing rules.

The KCN runtime exposes a streaming telemetry API at the capsule level. Each capsule has a unique identifier (the Capsule ID, derived from its Substrate axis seed) that you use to subscribe to its event stream.

The telemetry stream emits events for every karma delta, every Karma Loop phase transition, and every tensor axis update. Events are structured as JSON objects with a timestamp (HLC), the affected axes, the delta value, and the triggering observation. The DQA dashboard (included in the runtime package) provides a visual representation of the tensor state and karma balance in real time. For programmatic access, the telemetry API supports WebSocket and gRPC transports.

The KCN SDK is available for Python (primary), TypeScript/JavaScript, Rust, and Go. The Python SDK is the most complete — it includes the full DQA client, the capsule lifecycle API, the telemetry subscriber, and the Karma Loop simulation harness. The TypeScript SDK covers the DQA client and telemetry subscriber; it is designed for frontend and edge integrations.

The Rust and Go SDKs are lower-level — they expose the capsule state serialization format and the DQA wire protocol directly. They are intended for performance-critical integrations and custom substrate adapters. All SDKs are versioned against the KCN runtime and are available through the developer portal.

The Actor, Critic, and Audience are the three roles your code can occupy in the KCN's reinforcement learning architecture.

The Actor is the policy function — it takes the current capsule state (the tensor snapshot) as input and outputs an action (a karma delta proposal). You implement the Actor as a function that receives a CapsuleState object and returns an Action object. The Critic is the value function — it evaluates the Actor's proposed action against the current reward signal and returns a scalar value estimate. The Audience is the authority signal — it observes the Actor's behavior over time and adjusts the reward signal based on sovereign intent. In Sandbox, the Audience is a configurable rule set. In Transient Scale and above, the Audience is a trained model that you can fine-tune against your domain.

The recommended path has four stages. First, validate your capsule lifecycle logic in Sandbox — run at least 10⁶ capsule-cycles and verify that karma balances converge as expected. Second, enable the Hardened Substrate binding in your Sandbox configuration — this activates the physical RWA anchor simulation and surfaces any issues with your Sovereign axis logic before you touch real hardware.

Third, request a Transient Scale evaluation environment through the developer portal — this is a shared multi-tenant environment where your capsules run alongside other developers' capsules on real neuromorphic hardware. Fourth, once your capsules pass the Transient Scale evaluation criteria (karma convergence rate, DQA routing efficiency, and Ledger write latency), you can request a dedicated Transient Scale node. The full process typically takes 4–8 weeks from Sandbox validation to dedicated Transient Scale deployment.