The whole architecture, as one map

KYE Protocol™ is a living system of engines, agents, rails, schemas, gates and chapters that must stay coherent on every commit. The Architecture Graph renders that system the way an engineer actually reads it — a node-link map you can pan, zoom and search — so you grasp in one screen what a list takes an afternoon to trace. Click any node to light up its dependencies.

Architecture Graph, stage by stage

Demo data

You learn: The flow this page describes, one stage at a time. You can: Run it end to end.

  1. Blast radius

    KYE Protocol™

    Click a schema and watch every gate, generator and page that consumes it light up — so you know what one change touches before you make it.

  2. Coherence

    KYE Protocol™

    The same graph backs the Cohesion Cascade™ that fails CI when a source-of-truth edit doesn't ripple to its derived artefacts. The map shows you why.

  3. Onboarding

    KYE Protocol™

    A new engineer reads the whole protocol — hundreds of nodes across platform, developer, compliance and commercial macro groups — in minutes, not days.

How this widget is built
Demonstrates
KYE™ runtime
Components
  • The stages this page describes
Flow
Each stage in order, as the page sets it out. Architecture diagram
Used on
  • /graph/: On this page, after its opening.

Start a governed pilot Open the table view

Explore the graph

This is the same canonical graph the protocol uses to keep itself coherent — projected as a visual map instead of a sortable table. Filter by macro group or component category, search for any node, and click a node to focus its typed neighbours. Drag a node to reposition it; scroll to zoom.

Loading the architecture graph…

Honest rendering: every node and edge here is read from the protocol's own canonical dependency graph — engines, agents, rails, schemas, gates and constitution chapters, joined by the nine typed relationship verbs (produces, consumes, feeds, fetches-from, interacts-with, affected-by, impacted-by, connected-to, peer-of). It is the architecture, not a sketch of it.

Why a map and not a list

Because architecture is a graph, and a list flattens it. When you can see KYE Protocol™ as a graph, the things that matter to you as a builder or a reviewer become visible at a glance.

  • Blast radius. Click a schema and watch every gate, generator and page that consumes it light up — so you know what one change touches before you make it.
  • Coherence. The same graph backs the Cohesion Cascade™ that fails CI when a source-of-truth edit doesn't ripple to its derived artefacts. The map shows you why.
  • Onboarding. A new engineer reads the whole protocol — hundreds of nodes across platform, developer, compliance and commercial macro groups — in minutes, not days.

See the same data as a table

The same source of truth, two views

The Architecture Graph is a projection, not a parallel system — it reads the one canonical dependency graph and never invents its own. That single-root discipline is what lets KYE Protocol™ stay coherent at scale, and it's the reason regulated buyers can trust what they see.

  • One root, many views. The visual map here and the sortable cascade inventory table render the identical canonical graph — change the source once and both views update on the next build.
  • Typed, not decorative. Every edge carries one of nine relationship verbs, so the map is a queryable dependency graph an auditor can reason about — not an org chart.
  • Public-safe by construction. The map exposes node labels and component categories only; no internal mechanism content reaches this page, by the same patent-safety pass that guards every public surface.

Want the live data contract behind the map? Browse the schema catalogue or the chain-of-authority globe — two more views over the same canon.