Gyroscopic Alignment Models Lab – research and tooling for governance-ready AI coordination
G Y R O - G O V E R N A N C E
Gyroscopic ASI is an infrastructure for multi-domain network coordination that establishes the structural conditions for collective superintelligence governance and seamless cooperation between humans and machines in the era of Transformative AI (TAI) and Artificial General Intelligence (AGI) (see Bostrom, Superintelligence, 2014; Korompilias, Gyroscopic Global Governance, 2025).
Within this broader framework, Alignment Infrastructure Routing (AIR) provides a coordination layer for work, provenance, and governance logistics, while Moments Economy provides a monetary and settlement framework grounded in replayable coordination. This development is part of the Gyroscopic Global Governance (GGG) framework, which coordinates across four domains: Economy, Employment, Education, and Ecology. It builds upon:
- The Common Governance Model (CGM): a formal theory identifying the four capacities required for coherent governance.
- The Human Mark (THM): a classification system for Direct and Indirect Authority and Agency, with four displacement risks.
- The Gyroscope Protocol: a work classification system mapping contributions to the four governance capacities.
Alignment Infrastructure Routing (AIR) acts as the operational backbone, coordinating AI safety work and funding flows across projects. Together these components provide the coordination infrastructure for AI governance at scale while keeping authority and accountability with humans.
Gyroscopic ASI is not an autonomous agent, and does not interpret content or set policy. It provides shared state, verifiable provenance, and replayable measurement. Authority and accountability stay with humans at the application layer.
Modern AI treats the computer as a passive engine for evaluating frozen parameters. The Gyroscopic architecture inverts this relationship. It is a live meta-computer that recruits the hardware's native byte physics as its active inference medium.
The Transformer Paradigm
- Intelligence is stored in dead weights.
- The computer passively executes the model.
- Inference is a statistical query over frozen fields.
The Gyroscopic Paradigm
- Intelligence is stored in live occupation and resonance.
- The machine is the active substrate, making static parameters unnecessary.
- Inference is not a computed score or a probabilistic guess; it is the physical gyration itself.
- The XOR crossover, where the passive past constrains the mutated present to commit the future, is the native act of intelligence.
This fundamental shift transforms training, deployment, and optimization. The result is not merely a language model, but a universal computational condenser. Because all scientific and industrial domains eventually become computational artifacts, this architecture can index, compress, and reorganize the core structure of science, engineering, governance, and digital infrastructure.
A Compact Holonomic Quantum Virtual Machine (hQVM) for post-AGI coordination. Byte-driven, deterministically replayable, and runs on ordinary hardware.
Verified:
Algebraic quantum structure, holographic compression, and universal quantum computation ingredients do not require a multi-million-dollar cryogenic chandelier. They are geometric properties of discrete information processing on standard silicon. This Kernel is a tiny module that bypasses the hardware scaling nightmare of the quantum computing industry by treating "quantumness" not as a physical anomaly of subatomic particles, but as an algebraic necessity of structured information. It offers straightforward AI Optimizations and provides an infrastructure for Safe Superintelligence by Design.
Note:
Standard "quantum-inspired" methods, including Tensor Networks, Digital Annealing, and Quantum-Inspired Monte Carlo, are heuristic approximations. They use floating-point mathematics to simulate continuous physical quantum systems. This project does not belong to those categories. Gyroscopic is the infrastructure. It is an exact integer substrate on finite Ω using strict integer logic over finite fields. The hQVM routes bytes on that substrate by computing via the geometric phases of closed loops. The Gyroscopic runtime is the multicellular QCA execution layer for AI workloads.
Today, AI often acts as an opaque pipeline: information and decisions flow through systems that are hard to audit. The kernel makes coordination auditable: given a published append-only log of bytes, anyone can recompute the same state trajectory and check what was recorded.
The hQVM (Holonomic Quantum Virtual Machine) is a compact, finite-state kernel that turns byte logs into a single, reproducible state. It delivers proven computational advantages in execution speed, structural compression, and intrinsic tamper detection. Two parties with the same log always get the identical state without requiring a trusted server or timestamp. It uses exact integer arithmetic and does not rely on analog qubits or hardware noise. Its design intrinsically satisfies the foundational axioms of quantum computation through holonomic loops (Zanardi and Rasetti 1999; Pachos et al. 2000), including unitarity, non-cloning, contextuality, and complementarity, over a finite algebraic field. Where HQC literature realises these gates through adiabatic or non-adiabatic control loops on quantum hardware, the hQVM instantiates the same geometric structure as an exact GF(2) finite-state machine on silicon, opening the possibility of structural quantum advantage without quantum hardware. Exhaustive tests across its entire state space have verified this.
The state space is fixed and small: 4,096 reachable states, determined by a compact representation (three axes, left/right handedness, and six degrees of freedom). Any sequence of events (each represented as a byte) drives the state along a unique, reproducible path through this manifold. The kernel does not use learned models. It scales by fixed geometry rather than learned approximation.
The kernel's computational medium is QuBEC (Quantum Bose-Einstein Condensate): a condensed computational state with six internal binary orientation modes (dipoles), a four-phase spinorial gauge structure, and intrinsic ensemble stochasticity induced by the byte law. One step yields a 128-state future cone; two steps yield uniformization over all 4,096 reachable states. Together they replace costly continuous approximation with integer algebra on standard CPUs and GPUs, without qubits, cryogenics, or probabilistic hardware noise.
For orientation, see the Strategic Significance Brief. Normative specs are listed under Core Specifications in the Documentation section below.
Gyroscopic runtime is the multicellular AI runtime built on the hQVM router. It organizes Ω into a resonance-defined cell pool for runtime intelligence and structural observability.
It provides:
- Quantum Cellular Automaton execution: Cells evolve under the hQVM byte law, consuming runtime input as 4-byte words to navigate the holonomic state space.
- Local structural memories per cell: Rolling chirality and shell memories providing spectral views (Walsh-Hadamard and shell Krawtchouk surfaces) without floating-point approximations.
- Resonance-defined graph structure: Dynamic graph topology induced by resonance profiles over quantum-native observables (e.g., chirality, shell, state coincidence).
- SLCP reports and graph queries: Exact Spectral Light-Cone Parametrization records and resonance-based graph queries, providing structural AI orchestration across four bridge domains: Applications, Databases, Networks, and Transformers.
- Real-time AI Control: Uses structural state to dynamically manage LLM resource allocation (e.g., adjusting context patch sizes based on the thermodynamic state of the computation).
See Core Specifications below for the runtime document.
- Processing: Replayable stream-processing with deterministic recomputation, compact state updates, and composable operator signatures, suitable for event sourcing, reproducible workflows, and governance-grade logs.
- Speed: Byte words compile into operators, commutativity resolves through compact invariants, and the full reachable geometry is covered in only 2 steps, reducing structural work compared to classical search and replay.
- Security: Tamper-aware logs, divergence localization, replay-based verification, and compact provenance surfaces, grounded in a finite, enumerable state space with built-in error detection.
- Compression: Structural compression through compact state geometry, holographic boundary dictionaries, and operator compilation, enabling lossless but storage-efficient coordination records.
- Networks: Replay-based synchronization, shared replayable moments, and branch comparison across distributed participants using shared coordination state computed from append-only logs.
- Machine Learning: Eliminates structural computational bottlenecks by substituting floating-point heuristics with algebraic selection. Provides an interpretable finite latent layer, spectral primitives, and an audit-friendly bridge with verifiable provenance over model I/O traces.
Verified Results
All results below are verified by exhaustive computation over the entire reachable state space and all 256 byte operations. Oracle/query separations (Deutsch–Jozsa, Bernstein–Vazirani, hidden subgroup on the chirality register) are documented in the hQVM Features Report §9a.
| Verified result | What it means |
|---|---|
| 499 tests passing | Exhaustive coverage of the reachable state space and all 256 byte operations (over 10⁶ exact checks). |
| 4,096 reachable states | Finite, exhaustively testable manifold from rest. |
| 2-step uniformization | All 4096 states reached in exactly 2 byte steps with 16-to-1 multiplicity. |
| 128 next states per byte | 256-byte alphabet projects to 128 distinct next states with 2-to-1 symmetry. |
| Depth ≤ 2 state synthesis | Every reachable state has a byte witness of depth 0, 1, or 2. |
| Compiled operator signatures | Byte words collapse into affine signatures that compose without replay. |
| O(1) commutativity test | Commute iff same 6-bit q-class: one lookup. |
| Native spectral register | Exact Walsh-Hadamard and shell spectral structure on a 64-dimensional register. |
| Holographic boundary | |H|² = |Ω| = 64² = 4096; 8-bit state encoding (33% compression). |
| Universal holonomic ingredients | Stabilizer structure, entangling gates, contextuality, teleportation lifts, non-Clifford δ_BU phase. |
| 1.26B ops/s on commodity mini-PC | Native throughput on standard silicon. |
| Zero-transcendental AI control | Replaced softmax and cosine similarity with integer algebra in a live 1B-parameter LLM. |
| 64-wide hybrid lowering | External tensors tile into native 64-wide blocks with structured P_Q + residual D_Q contraction. |
✅ hQVM Features Report is the master catalog: every verified feature with evidence source, verification tier, and experiment script.
Integrity and Tamper Detection: Built-in self-dual [12,6,2] code with provenance checks. Substitutions reduce to shadow partners, adjacent swaps to shared q-class, deletions to horizon stabilizer conditions.
Alignment Infrastructure Routing (AIR) sits within the broader framework of Gyroscopic Collective Superintelligence, routing work, funding, provenance, and governance across AI safety and public-interest programmes.
AIR serves as a practical bridge between human contribution, programme administration, and verifiable machine-assisted workflows.
While most funding routes require institutional access, credentials, or existing lab affiliation, AIR addresses this accessibility gap by providing a reliable way to turn distributed human contribution into stable paid AI safety work.
Safety work and pay: AIR helps labs, fiscal hosts (organisations that hold and disburse funds for projects), and contributors turn safety work (evaluations, red-teaming, interpretability, documentation) into paid, verifiable contributions. It uses the Gyroscope Protocol and The Human Mark (class classification for Direct and Indirect Authority and Agency) to produce attested work receipts so sponsors can verify what was done without relying on informal reports.
Contributors map their work to four governance capacities, which act as a career ladder to unlock higher funding tiers:
- 🤝 Intelligence Cooperation,
- 🧩 Inference Interaction,
- 📚 Information Curation,
- and 🧭 Governance Management.
Governance logistics: Tracking how information and authority move through decision systems is treated with the same rigour as supply chains. AIR provides full replayable histories (“genealogies”) and coherence metrics for governance quality, and supports verifiable compliance with standards such as ISO 42001 and the EU AI Act.
Moments Economy is part of Gyroscopic Collective Superintelligence broader framework. It extends the same replayable coordination infrastructure into economic distribution, making money a function of verified coordination capacity rather than debt issuance.
A fixed total supply of 7.94 × 10²⁶ Moment-Units (MU), the Common Source Moment (CSM), is derived once from the caesium-133 atomic frequency standard and the finite verification space of the hQVM. This gives the system a physically anchored capacity envelope rather than a discretionary monetary base. Its native commodity is the AI Generated Token: a verified inference event from the intersection of human experience and AI processing. No debt issuance, no discretionary monetary policy. Every settlement is a replayable, verifiable history.
CSM supports a global Unconditional High Income (UHI) of 240 MU per day per person, tiered distributions for wider responsibility, and complete governance records. Under verified capacity analysis, this supply supports global UHI for approximately 1.12 trillion years. Every settlement is a replayable, verifiable history rather than an opaque update on a central ledger.
Moments Economy builds on the same infrastructure as AIR, but adds the economic layer: unit definition, issuance logic, settlement structure, and long-horizon distribution design.
- 🧭 Strategic Significance Brief - Why this kernel matters for ASI and governance
- 🔮 hQVM Kernel Implications and Potential - Advantages and use cases
- ✅ hQVM Features Report - Master inventory of verified quantum and physics features (Tiers A/B/C)
- 🚛 AIR Brief - Safety work and programs
- 🧪 Computational Climate Control Brief - How the architecture bypasses floating-point hardware bottlenecks
- 💰 Moments Economy Whitepaper - Monetary and civil governance framework grounded in replayable coordination
Read in layer order: Foundations → SDK → QuBEC Theory → Runtime.
| Document | Role | Primary audience | |
|---|---|---|---|
| 📖 | Gyroscopic ASI Foundations | Kernel architecture, byte law, state space, replay, and governance measurement | Kernel implementers |
| 🧠 | Quantum Computing SDK | Computational contract: operations, semantics, conformance | SDK users and integrators |
| 🧪 | QuBEC Theory | Mathematical foundation: thermodynamics, hardware-tier architecture, transport, transforms, operator lowering, quantum structure | Researchers and reviewers |
| ⚙️ | Gyroscopic Runtime Specification | Multicellular QCA execution, bridges, and operational lowering | Runtime implementers |
| 📐 | Specifications Formalism | Proofs, byte formalism, and formal lemmas | Formal verification |
| 🌐 | Holographic Algorithm Formalization | State-space encoding and holographic dictionaries | Encoding and compression |
- 🚛 AIR Logistics Framework - Governance flows and verification
- 💰 Moments Economy Architecture - Monetary settlement from coordination
- 📜 Moments Genealogies Specification - Replayable coordination history
- 💳 Pulse Wallet Specification - Capacity wallet for grammar-compliant recognition and repair
Core quantum SDK contract is in the table above. Extension specs:
- 🔗 Multi-Agent Holographic Networks - Distributed model testing
- 🌐 The Holographic Web - Internet coordination layer
- 🧬 Substrate: Physical Memory Specification - Memory and carrier layout
All kernel properties verified by exhaustive test suites (499 tests, all passing).
- ✅ hQVM Features Report - Master inventory of verified quantum and physics features (Tiers A/B/C)
- 📊 Physics Tests Report - Kernel state verification
- 📊 Moments Tests Report - Ledger replay tests
- 📊 hQVM Verification Report - Algebraic properties verified (185 tests)
- 📊 hQVM Verification Report II - Extended kernel and SDK tests (122 tests)
- 📊 hQVM Climate Tests Report - Climate helper and transport diagnostics validation
- 📊 hQVM Speed Tests Report - Native throughput benchmarks on standard silicon
- 📊 Measurement Tests Report - Governance balance metrics and epistemic vs empirical evaluation
Canonical source: gyrogovernance/tools (docs/the_human_mark/). Local reference copies:
- 📖 The Human Mark (THM) - Canonical Mark block and alignment principles
- 📖 THM Brief - Short introduction
- 📖 THM Paper - Full taxonomy and regulatory specification
- 📖 THM Grammar - PEG specification for tagging and validation
- 📖 THM Specs - Implementation guidance for systems and evaluations
- 📖 THM Terms - Mark-consistent framing for AI safety terminology
- 📖 THM In the Wild - Analysis of 655 jailbreak prompts with THM classifications
- 📖 THM Jailbreak - Jailbreak evaluation methodology
- 📖 THM MechInterp - Mechanistic interpretability mapping
CGM foundations
- 📖 Common Governance Model (CGM) - Shared coordination theory
- 📖 CGM Logic - Construction chain from common source to operational structure
- 📖 CGM Research Program - Comprehensive research guide and derivation map
CGM analyses
- 📖 Analysis: CGM Constants - Mathematical structure of fundamental constants and the aperture parameter
- 📖 Analysis: CGM Units - Geometric foundation of physical units and energy scales
- 📖 Analysis: Monodromy - Geometric memory across closed loops and fine-structure connections
- 📖 Analysis: Gravity - Gravitational theory from causal preservation of ancestry
- 📖 Analysis: Gravity Note - Work-in-progress companion to the gravity analysis
hQVM analyses
- 📖 Analysis: Gyroscopic Multiplication - Arithmetic layer and cross-layer structural analysis
- 📖 Analysis: hQVM Cohomology - Étale cohomology, Grothendieck structure, and transport obstructions
- 📖 Analysis: hQVM Percolation - Generator-restricted percolation and universality of ancestry preservation
- 📖 Analysis: hQVM Percolation Note - Companion note to the percolation analysis
- 📖 Analysis: hQVM Wavefunction - Wavefunction chart analysis of the hQVM kernel
- 📖 Analysis: hQVM Wavefunction Corrections - Coordinate and signature reference for the wavefunction kernel
If you are evaluating this work for research, policy, or implementation:
- Open an issue to discuss
- Email: basilkorompilias@gmail.com
- I am actively seeking collaborators and roles in AI governance and safety.
src/constants.py: Transition law, kernel constants, horizons, gates, and observablessrc/api.py: Precomputed tables, chirality register, word signatures, Walsh helpers, and public algebra APIsrc/kernel.py: Reference kernel execution and replay surfacessrc/sdk.py: Public SDK surface for state, Moments, spectral, tensor, and runtime operationssrc/tools/gyroscopic/: Gyroscopic kernel backend and runtime surfaces; llama.cpp hook (external/llama.cpp/ggml/src/ggml-gyroscopic/)src/app/: AIR coordinator, events, domain ledgers, aperture (governance balance metric), console, and CLIdocs/: Specifications, reports, and supporting theorytests/: Exhaustive verification suites for kernel physics, hQVM properties, SDK surfaces, and governance measurement
Create an environment and install dependencies (NumPy is required; the rest are in the repo tooling).
The public SDK surface is exposed through src/sdk.py. The native compute backend lives in src/tools/gyroscopic/ and is used automatically when available to accelerate algebraic workloads.
The Python SDK surface is organized into ClimateOps (QuBEC climate helpers) and RuntimeOps (native kernel entry points) namespaces, aligned with the Quantum Computing SDK specification. See src/sdk.py and src/tools/gyroscopic/ops.py.
Native backend note: prebuilt Windows binaries are included for convenience. On macOS and Linux, the native backend builds automatically on first run when standard compiler tooling is available. If native build is unavailable, the Python fallback remains functional.
For native build details, see:
src/tools/gyroscopic/(native backend sources and helpers)- llama.cpp Gyroscopic Backend
The Console provides a browser-based interface for managing project contracts:
# First-time setup: install dependencies and initialise the kernel transition table
python air_installer.py
# Run the console (starts both backend and frontend)
python air_console.pyThe console will be available at http://localhost:5173 (frontend proxies API requests to backend on port 8000). The installer automatically initialises the kernel transition table and project structure, so you are ready to start creating projects immediately.
See the Console README for detailed architecture, API endpoints, and development information.
The CLI provides a command-line workflow for syncing and verifying projects:
python air_cli.pyThis runs: Compile Projects -> Generate Reports -> Verify Bundles.
The CLI is optional if you are using the Console, but useful for batch operations, automation, or when working without a browser interface.
python -m pytest -v -s tests/from src.app.coordination import Coordinator
from src.app.events import Domain, EdgeID, GovernanceEvent
c = Coordinator()
# Shared-moment stepping
c.step_bytes(b"Hello world")
# Application-layer governance update (ledger event)
# Note: magnitude_micro and confidence_micro are integers (MICRO = 1,000,000)
from src.app.events import MICRO
c.apply_event(
GovernanceEvent(
domain=Domain.ECONOMY,
edge_id=EdgeID.GOV_INFO,
magnitude_micro=1 * MICRO, # 1.0 in micro-units
confidence_micro=int(0.8 * MICRO), # 0.8 in micro-units
meta={"source": "example"},
),
bind_to_kernel_moment=True,
)
status = c.get_status()
print(status.kernel) # current kernel state
print(status.apertures) # per-domain balance (cycle vs gradient) for Economy, Employment, EducationMIT Licence - see LICENSE for details.
@software{Gyroscopic_ASI_2026,
author = {Basil Korompilias},
title = {Gyroscopic ASI hQVM Kernel},
year = {2026},
url = {https://github.com/gyrogovernance/superintelligence},
note = {Holonomic Quantum Virtual Machine for Post-AGI coordination through physics-based state transitions and geometric loop computation}
}Architected with ❤️ by Basil Korompilias
Redefining Intelligence and Ethics through Physics
🤖 AI Disclosure
All code architecture, documentation, and theoretical models in this project were authored and architected by Basil Korompilias.
Artificial intelligence was employed solely as a technical assistant, limited to code drafting, formatting, verification, and editorial services, always under authentic human supervision.
All foundational ideas, design decisions, and conceptual frameworks originate from the Author.
Responsibility for the validity, coherence, and ethical direction of this project remains fully human.
Acknowledgements:
This project benefited from AI language model services accessed through LMArena, Cursor IDE, OpenAI (ChatGPT), Anthropic (Opus), and Google (Gemini).