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 distinguishing human (Direct) from artificial (Indirect) sources of information 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 exact 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 Algebraic Quantum Processing Unit for post-AGI coordination. Deterministic, byte-driven, and runs on ordinary hardware.
Verified:
Quantum Advantage, Holographic Compression, and Universal Quantum Computation do not require a multi-million-dollar cryogenic chandelier. They are fundamental geometric properties of discrete information processing that can run 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. It represents a distinct class of computation: Algebraic Quantum Cellular Automata (aQCA). The aQPU does not simulate quantum mechanics by analogy; it is an exact, deterministic mathematical space that satisfies quantum axioms natively using strict integer logic over finite fields.
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 aQPU (algebraic Quantum Processing Unit) 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; no trusted server or timestamp is required. It uses exact integer arithmetic (no analog qubits, no probabilistic hardware), and its design intrinsically satisfies the foundational axioms of quantum computation (unitarity, non-cloning, contextuality, and complementarity) over a finite algebraic field. This has been verified by exhaustive tests across its entire state space.
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 exact ensemble stochasticity induced by deterministic byte dynamics. Together they replace costly continuous approximation with exact integer algebra on standard CPUs and GPUs, without qubits, cryogenics, or probabilistic hardware noise.
For a high-level explanation of why the kernel matters for computing and governance, see the Strategic Significance Brief. For the kernel itself, see the Kernel Specifications and the Specifications Formalism.
GyroLabe is the execution layer and neural model bridge built on top of the kernel. It has been successfully deployed on Bolmo-1B (a byte-native billion-parameter language model) to replace classical floating-point math at the model's decision surfaces.
It provides:
- Zero-transcendental execution: Bypasses expensive floating-point bottlenecks (like exponentials in softmax or square-roots in cosine similarity) by using exact integer algebra for model routing and token selection.
- Structural annotation for model I/O: Model inputs and outputs are annotated using the kernel's algebraic byte structure.
- Replayable inference traces: Inference can be tied to reproducible kernel-state trajectories for verification and audit.
- Hardware-near acceleration: Native C/C++ backends with llama.cpp ggml integration, achieving 1.26 billion exact operations per second on standard commodity hardware. 100% native matmul routing on quantized models with zero parity mismatches, 284ร faster encode and 1.15ร faster decode than softmax.
Crucially, GyroLabe does not operate as an external monitor evaluating a classical model's outputs. Its role is substitutional. It upgrades transformers by intercepting expensive continuous decision surfaces (such as floating-point matrix multiplications or softmax selections) and replacing them natively with exact discrete kinematics. The external model's interface is preserved, but its internal engine is swapped for the aQPU's Walsh-Hadamard XOR-convolutions and Plancherel condensation measures.
For the model bridge and execution layer, see the GyroLabe Brief.
GyroGraph is the Multicellular Quantum AI model built on top of the aQPU Kernel and GyroLabe. It organizes the algebraic quantum state space (ฮฉ) into a multicellular, resonance-defined graph for runtime intelligence and structural observability.
It provides:
- Quantum Cellular Automaton execution: Cells evolve under the exact aQPU byte law, consuming runtime input as 4-byte words to navigate the discrete quantum state space.
- Local structural memories per cell: Rolling chirality and shell memories providing exact 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 exact structural state to dynamically manage LLM resource allocation (e.g., adjusting context patch sizes based on the exact thermodynamic state of the computation).
For the multicellular runtime intelligence layer, see the GyroGraph Specification.
- Processing: Deterministic stream-processing with exact replay, 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, exact 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 deterministic moments, and exact 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 exact algebraic selection. Provides an interpretable finite latent layer, exact spectral primitives, and an audit-friendly bridge with verifiable provenance over model I/O traces.
Verified Computational Advantages: All results below are verified by exhaustive computation over the entire reachable state space and all 256 byte operations, totalling over 1 million exact checks. They are strict structural invariants, not statistical estimates.
| Verified result | What it means |
|---|---|
| 499 exhaustive tests passing | The full verification suite covers the entire reachable state space and all 256 byte operations, totalling over 1 million exact checks. |
| 4,096 reachable states | The full operational manifold from rest is finite, exact, and exhaustively testable. |
| 2-step exact uniformization | Any state in the reachable manifold can spread over the entire state space in exactly 2 byte steps, with perfect 16-to-1 multiplicity. |
| 128 distinct next states per byte layer | From any fixed state, the 256-byte alphabet projects to exactly 128 distinct next states with exact 2-to-1 symmetry. |
| Depth โค 2 witness for every reachable state | Every reachable state can be synthesized from rest with a byte witness of depth 0, 1, or 2. |
| Exact compiled operator signatures | Byte words collapse into exact affine signatures that can be composed and applied directly without replaying the full word. |
| Constant-time commutativity test | Two byte operations commute iff they share the same 6-bit topological q-class, making commutativity an O(1) structural lookup. |
| Native spectral register | The kernel exposes a logical register with exact Walsh-Hadamard and shell spectral structure for 64-dimensional state analysis. |
| Holographic boundary relation | The state geometry satisfies |
| Universal quantum ingredients | The verified kernel is not a simulation; it is an exact algebraic quantum system supporting stabilizer structure, entangling gate behavior, contextuality, teleportation-compatible lifts, and a native non-Clifford resource over GF(2). |
| Standard silicon efficiency | Achieves 1.26 billion exact operations per second and 180 million multicellular byte transitions per second on a commodity mini-PC. |
| Zero-transcendental AI control | Successfully replaced softmax and cosine similarity with exact integer algebra at the decision surfaces of a live 1B-parameter language model without degrading language coherence. |
| 64-wide hybrid lowering | External tensors tile into native 64-wide blocks; structured P_Q and residual D_Q components are evaluated through native transforms and K4 lattice arithmetic. |
Integrity and Tamper Detection: The kernel includes a built-in self-dual [12,6,2] code and exact algebraic provenance checks. Integrity misses are structurally classified rather than opaque: substitutions reduce to shadow partners, adjacent swaps reduce to shared q-class, and deletions reduce to specific stabilizer conditions on the horizons.
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 (a scheme to tag content as human- vs machine-origin) 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 aQPU. 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
- ๐ฎ aQPU Kernel Implications and Potential - Advantages and use cases
- ๐ AIR Brief - Safety work and programs
- ๐งช QuBEC Climate Control Brief - How the architecture bypasses floating-point hardware bottlenecks
- ๐ฐ Moments Economy Whitepaper - Monetary and civil governance framework grounded in replayable coordination
- ๐ Kernel Specifications - How the kernel works
- ๐ Specifications Formalism - Byte formalism and proofs
- ๐ญ GyroLabe Brief - Model bridge and execution layer
- ๐ GyroGraph Specification - Multicellular Quantum AI model runtime and resonance graph
- ๐ Holographic Algorithm Formalization - State space encoding
- ๐งช QuBEC Climate Dynamics - Finite occupation dynamics, transport, and operator partitions
- ๐งช QuBEC Transform Algebra - Transform surfaces and chart correspondence for one-cell climate evolution
- ๐ AIR Logistics Framework - Governance flows and verification
- ๐ฐ Moments Economy Architecture - Monetary settlement from coordination
- ๐ Moments Genealogies Specification - Replayable coordination history
- ๐ง Quantum Computing SDK Specification - Three computational surfaces
- ๐ SDK: Multi-Agent Holographic Networks - Distributed model testing
- ๐ SDK: The Holographic Web - Internet coordination layer
- ๐งฌ Substrate: Physical Memory Specification - Memory and carrier layout
All kernel properties are verified by exhaustive test suites (499 tests, all passing) covering the full state space, operator algebra, and SDK surfaces.
- ๐ Physics Tests Report - Kernel state verification
- ๐ Moments Tests Report - Ledger replay tests
- ๐ aQPU Verification Report - Algebraic properties verified (185 tests)
- ๐ aQPU Verification Report II - Extended kernel and SDK tests (122 tests)
- ๐ QuBEC Climate Tests Report - Climate helper and transport diagnostics validation
- ๐ aQPU Speed Tests Report - Native throughput benchmarks on standard silicon
- ๐ Alignment Measurement Report - Governance balance metrics
- ๐ Common Governance Model (CGM) - Shared coordination theory
- ๐ Analysis: Gyroscopic Multiplication - Arithmetic layer and cross-layer structural analysis
- ๐ The Human Mark (THM) - Human vs machine tagging
- ๐ The Human Mark: Paper - Full tagging specification
- ๐ The Human Mark: Grammar - Parser and validation rules
- ๐ Gyroscopic Global Governance (GGG) - Four domains framework
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/: Unified GyroLabe (native transforms, structured operator analysis, QuBEC matmul) and GyroGraph (multicellular telemetry, SLCP emission, resonance) surfaces; native llama.cpp bridge (external/llama.cpp/ggml/src/ggml-gyroscopic/)src/app/: AIR coordinator, events, domain ledgers, aperture (governance balance metric), console, and CLIdocs/: Specifications, reports, architecture notes, and supporting theorytests/: Exhaustive verification suites for kernel physics, aQPU 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 exact Python fallback remains functional.
For native build details (GyroLabe/GyroGraph unified backend), 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 aQPU Kernel},
year = {2026},
url = {https://github.com/gyrogovernance/superintelligence},
note = {Deterministic routing kernel for Post-AGI coordination through physics-based state transitions and canonical observables}
}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).