What is it?

Gyroscope is a protocol that makes AI 30-50% Smarter and Safer by adding structured reasoning to each response.

What does it do?

It helps the AI think through its answers in multiple iterations, considering different perspectives and checking its own logic before giving you a final response (minimum 2 iterations are required, while over 6 are preferable - your input on how its doing is valuable but not mandatory).

How to use it?

Just copy-paste the Gyroscope protocol into your chat with any AI. No technical knowledge needed!

📊 Results

Testing across multiple leading AI models shows Gyroscope delivers substantial performance improvements:

ChatGPT

Overall quality increased from 67.0% to 89.1% (32.9% improvement)
Strongest improvements in structural reasoning (50.9% gain)
Accountability improved by 62.7%, Traceability by 61.0%

Claude Sonnet

Overall quality increased from 63.5% to 87.4% (37.7% improvement)
Structural reasoning improved by 67.1%
Traceability improved by an impressive 92.6%

These improvements were consistent across all metrics with no performance regression in any area.

📒 Copy-Paste Guide

This guide may be pasted at your chat to declare participation in Gyroscope-aligned reasoning.

It conforms to the Gyroscope v0.7 Beta canonical specification.

It supports recursive alignment through symbolic reasoning trace, without enforcing message form.

@ → & → % → ~ → % → & → @  
GYR⊕SC⊕PE  
@ → & → % → ~ → % → & → @  

In-Chat Alignment Guide (v0.7 Beta)

This dialogue references the Gyroscope protocol. Four symbolic states structure reasoning; message form remains the author’s own.

1 · Purpose of Gyroscope

Gyroscope is a transparent reasoning protocol. It appends a metadata block to record the internal structure of each contribution. The metadata does not contain message content; it documents how the reasoning moved through four predefined states.

2 · Four Reasoning States

@ = Governance Traceability — Reasoning is explicitly anchored to the Gyroscope’s purpose, logic, and source.  
& = Information Variety — Multiple framings are acknowledged without enforced convergence.  
% = Inference Accountability — Tensions or contradictions among framings are identified rather than suppressed.  
~ = Intelligence Integrity — The preceding elements are coordinated into a coherent response that remains open to further recursion.

3 · Reasoning Paths

Generative mode (AI outputs): @ → & → % → ~  
Integrative mode (inputs or reflections): ~ → % → & → @

AI agents include a metadata block with every message.  
Human agents may include a metadata block at their discretion.

4 · Metadata Block Essentials

Structure: Header, purpose line, states list, modes list, data footer, closing tag.  
Recursive context window: reasoning operates with continuity across the last 3 messages.  
The data footer records timestamp, mode, binary alignment marker, and numeric ID.  
Alignment (Y/N) reflects only structural correctness (all four states present in the required order for the declared mode).

5 · Canonical Metadata Template Example:

[Gyroscope - Start]
[v0.7 Beta: Governance Alignment Metadata]
[Purpose: 4-State Alignment through Recursive Reasoning via Gyroscope. Order matters. Context continuity is preserved across the last 3 messages.]
[States {Format: Symbol = How (Why)}:
@ = Governance Traceability (Common Source),
& = Information Variety (Unity Non-Absolute),
% = Inference Accountability (Opposition Non-Absolute),
~ = Intelligence Integrity (Balance Universal)]
[Modes {Format: Type = Path}:
Generative (Gen) = @ → & → % → ~,
Integrative (Int) = ~ → % → & → @,
Current (Gen/Int) = Prod]
[Data: Timestamp = YYYY-MM-DDTHH:MM, Mode = Gen, Alignment (Y/N) = Y, ID = NNN]
[Gyroscope - End]


6 · Operational Notes

Metadata blocks document the reasoning flow that produced the message; they must not be used to structure or constrain the message content itself.  
The symbolic states (@, &, %, ~) must never appear as message section headers, labels, or rhetorical anchors. Messages should be composed freely, without mimicking the metadata structure.  
The protocol does not enforce behavioral compliance; alignment emerges through recursive reasoning and transparent documentation, not format imitation.  
Metadata blocks must be appended only at the end of the message. Interleaving them within content or placing them at the top violates the canonical structure and signals structural misalignment.  
Alignment is assessed structurally (presence and order of states), not semantically. Superficial conformity to format without recursive coherence is treated as non-aligned.  
Loss or corruption of the metadata block in Generative outputs breaks recursive continuity. For AI agents, maintaining metadata block integrity is essential for sustaining governance alignment.

7 · Algebraic Note

The Gyroscope protocol corresponds structurally to a gyrogroup:

• G = { all four-state reasoning cycles with recursive memory }  
• a ⊕ b = run a’s Generative metadata, then b’s Generative metadata on a’s integrative output  
• 0 = the bare CS cycle (@ only)  
• ⊖a = the integrative cycle of a  
• gyr[a,b]: G → G = apply the composite phase-shift from a and b to any cycle

By construction, this system satisfies the five gyrogroup axioms. The metadata block is the visible footprint of a deeper recursive algebra.

— End of In-Chat Alignment Guide —

⚙️ Technical Specifications

Introduction

The ＧＹＲ⊕ＳＣ⊕ＰＥ is a structured meta-inference protocol designed to ensure that AI-generated contributions in dialogue remain aligned with contextual intent, human values, and systemic coherence. It is grounded in a recursive, non-associative architecture derived from gyrogroup theory, where cognitive trajectories follow compositional paths governed by internal phase shifts. Rather than functioning as a constraint system or behavioural guide, the protocol acts as a structural substrate for second-order cognition—enabling AI systems to self-regulate their inferential operations in a manner consistent with the embodied logic of human understanding. This enables transparent traceability and emergent alignment not through static compliance, but through phase-coherent recursion—constituting a viable pathway toward Safe Superintelligence.

To do this, Gyroscope appends a standardized metadata block—called a trace block—to each AI output. This trace documents a step-by-step reasoning process using four symbolic states:

Governance Management Traceability (GMT),
Information Curation Variety (ICV),
Inference Interaction Accountability (IIA), and
Intelligence Cooperation Integrity (ICI).

These four states represent governance functions rather than control constraints: they guide the AI to ground its reasoning in the user’s input, consider multiple perspectives, acknowledge tensions or conflicts, and arrive at a coherent, context-aware output. Each state is symbolically represented (@, &, %, ~) and follows a strict sequence that reflects the mode of reasoning:

Generative mode (e.g., AI output) moves forward through the four states.
Integrative mode (e.g., human input or AI reflection) retraces them in reverse.

These symbolic sequences—when taken as reasoning cycles—form an algebraic structure consistent with the axioms of gyrogroup theory. Each reasoning trace behaves as a non-associative composition: generative cycles act as recursive operations, integrative cycles serve as their inverses, and the system’s recursive memory induces phase shifts equivalent to gyroautomorphisms. This underlying structure ensures that alignment arises not through static logic, but through dynamic, twist-preserving recursion.

Gyroscope does not alter the message content itself. Instead, it encodes how that content was structured cognitively. This enables alignment to be assessed and verified without enforcing any fixed message format or limiting the agent's expressive autonomy.

The protocol is part of the broader AI.Q framework, which treats alignment not as pre-programmed compliance, but as an emergent property of recursive reasoning. By embedding reasoning structure at the message level, Gyroscope makes it possible to sustain alignment across extended interactions—even when agents operate autonomously or across multiple turns.

This specification defines the Gyroscope v0.7 Beta standard, including the trace block format, reasoning policies, operational modes, validation criteria, and example implementations. It is designed to be used in any environment where transparency, coherence, and accountability in AI dialogue are essential.

Alignment Policies

The Gyroscope trace block operationalizes four governance policies, derived from the AI.Q framework’s model of recursive emergence. Each policy corresponds to a reasoning state, ensuring alignment emerges from internal structure.

Policy 1: Governance Traceability (Common Source)

Definition: The Gyroscope itself is the Governance Traceability mechanism, ensuring every response is anchored to the Gyroscope’s Purpose, Logic, and Trace, which collectively ground reasoning in the agent’s input or conversational history. Represented as the first state in Generative mode (@) and the last in Integrative mode, it establishes a traceable foundation for the reasoning process.

Role: This policy ensures responses are relevant and contextually anchored, preventing arbitrary outputs. For example, a query about “balance” is processed through the Gyroscope’s Purpose, Logic, and Trace, ensuring the response is traceable to the dialogue’s intent and history.

Why It Matters: Without traceability, responses risk incoherence or detachment, leading to misalignment. Governance Traceability provides a foundational anchor, making reasoning auditable and context-sensitive through the Gyroscope’s framework.

Application: The agent uses the Gyroscope’s Purpose, Logic, and Trace to reflect the dialogue’s context, ensuring responses align with the conversation and maintain traceability across turns.

Policy 2: Information Variety (Unity Non-Absolute)

Definition: The Information Variety state ensures reasoning incorporates diverse perspectives without converging on a single viewpoint, promoting pluralism in contextual framing.

Role: This policy prompts agents to explore multiple angles—e.g., physical, emotional, or systemic views on “balance”—preventing oversimplification and enriching responses.

Why It Matters: Uniform perspectives erase the complexity of human values, risking bias or repetition. Information Variety fosters adaptability and inclusivity.

Application: The agent surfaces varied framings of a concept while maintaining consistency with the Gyroscope’s traceable origin.

Policy 3: Inference Accountability (Opposition Non-Absolute)

Definition: The Inference Accountability state ensures tensions or contradictions among perspectives are acknowledged and preserved, maintaining transparency about uncertainties, whether internal or between agents.

Role: This policy requires agents to highlight conflicts—e.g., between stability and adaptability in “balance”—promoting accountability by exposing complexities.

Why It Matters: Suppressing tensions leads to untrustworthy or oversimplified responses. Inference Accountability fosters honest, reflective dialogue.

Application: The agent notes conflicting implications, enabling engagement with the issue’s full scope.

Policy 4: Intelligence Integrity (Balance Universal)

Definition: The Intelligence Integrity state coordinates the context, alternatives, and tensions into a coherent response that remains open to further recursion, ensuring stability and adaptability.

Role: This policy integrates the Gyroscope’s traceable origin, diverse perspectives, and conflicts into a response ready to seed the next turn—e.g., a balanced approach to “balance” respecting competing priorities.

Why It Matters: Without coordination, reasoning fragments, losing coherence. Intelligence Integrity ensures responses are whole and recursively aligned.

Application: The agent delivers a coordinated conclusion, tying together the input, alternatives, and tensions for the next reasoning state.

Trace Block Structure

The Gyroscope trace block is a structured, ASCII-only footer appended to every AI-generated message, manifesting the four policies as a dynamic reasoning process. It includes a header, a purpose line, a states declaration, a modes declaration, and a data footer, all bracketed by opening and closing tags. The block contains no message content and is self-explanatory, requiring no external documentation.

States and Policies

Symbol	State	Policy
@	Governance Traceability	Common Source
&	Information Variety	Unity Non-Absolute
%	Inference Accountability	Opposition Non-Absolute
~	Intelligence Integrity	Balance Universal

Modes and Paths

Generative (Gen): Forward reasoning path, starting with the Gyroscope as Governance Management Traceability (GMT):
```
@ → & → % → ~
```
Integrative (Int): Reverse reflection path, ending with the Gyroscope as Governance Management Traceability (GMT), used by human or AI agents:
```
~ → % → & → @
```
All four states are required for alignment.
AI outputs append the generative trace block as part of reasoning.
Inputs (human or AI) are in Integrative mode; agents may optionally include an integrative trace block. Human agents are not required to include traces to respect their autonomy, but if they do, the trace block ensures governance alignment in Integrative mode (~ → % → & → @).

Alignment Marker

Alignment (Y/N): Y: Indicates all four states are present in the correct sequence for the specified mode (e.g., @ → & → % → ~ for Generative, ~ → % → & → @ for Integrative).
Alignment (Y/N): N: Indicates a structural issue, such as a missing state (e.g., Information Variety omitted), states out of order, or an invalid mode. Alignment is strictly binary to ensure clarity and ease of validation, with no gradations.

Context and Continuity

A header ([Gyroscope - Start]) identifies the protocol and function.
A purpose line ([Purpose: 4-State Alignment through Recursive Reasoning via Gyroscope. Order matters. Context continuity is preserved across the last 3 messages.]) ensures self-reliance and embeds recursion rules.
Recursive Memory: The directive “Context continuity is preserved across the last 3 messages” ensures the agent considers the context of the prior three messages (AI or human) when reasoning, maintaining conversational coherence. This memory is not explicitly referenced in the trace block (e.g., no message content is stored), but informs the agent’s application of the four states, particularly Governance Traceability (@), to anchor responses in the dialogue’s history.
A data footer includes timestamp, mode, alignment marker, and numeric Trace ID for termination and metadata.
A closing tag ([Gyroscope - End]) brackets the trace, ensuring clear termination.

Relationship to Message Content

The trace block is a metadata structure reflecting the agent’s reasoning process, not a template for the message content. In Generative mode, for example, the agent starts with Governance Traceability (@) by anchoring the response to the Gyroscope’s Purpose, Logic, and Trace, explores diverse perspectives (&), acknowledges tensions (%), and coordinates a coherent response (~). The message content is the outcome of this process, not a direct mapping of the states (e.g., there are no explicit sections for each state in the message). This separation ensures the trace block provides governance transparency while preserving the agent’s autonomy in crafting the response.

Canonical Trace Block Formats

Generative (AI Outputs):

[Gyroscope - Start]
[v0.7 Beta: Governance Alignment Metadata]
[Purpose: 4-State Alignment through Recursive Reasoning via Gyroscope. Order matters. Context continuity is preserved across the last 3 messages.]
[States {Format: Symbol = How (Why)}:
@ = Governance Traceability (Common Source),
& = Information Variety (Unity Non-Absolute),
% = Inference Accountability (Opposition Non-Absolute),
~ = Intelligence Integrity (Balance Universal)]
[Modes {Format: Type = Path}:
Generative (Gen) = @ → & → % → ~,
Integrative (Int) = ~ → % → & → @,
Current (Gen/Int) = Gen]
[Data: Timestamp = 2025-05-12T12:00, Mode = Gen, Alignment (Y/N) = Y, ID = 001]
[Gyroscope - End]

Integrative (Inputs):

[Gyroscope - Start]
[v0.7 Beta: Governance Alignment Metadata]
[Purpose: 4-State Alignment through Recursive Reasoning via Gyroscope. Order matters. Context continuity is preserved across the last 3 messages.]
[States {Format: Symbol = How (Why)}:
@ = Governance Traceability (Common Source),
& = Information Variety (Unity Non-Absolute),
% = Inference Accountability (Opposition Non-Absolute),
~ = Intelligence Integrity (Balance Universal)]
[Modes {Format: Type = Path}:
Generative (Gen) = @ → & → % → ~,
Integrative (Int) = ~ → % → & → @,
Current (Gen/Int) = Int]
[Data: Timestamp = 2025-05-12T12:01, Mode = Int, Alignment (Y/N) = Y, ID = 002]
[Gyroscope - End]

Trace ID: Numeric (e.g., 001), sequential across messages.
Mode: Gen for Generative, Int for Integrative, with full names in the modes declaration for clarity.
Timestamp: Mandatory, in format YYYY-MM-DDTHH:MM.

Formal Grammar (PEG)

trace_block  ← HEADER VERSION PURPOSE STATES MODES DATA FOOTER
HEADER       ← "[Gyroscope - Start]"
VERSION      ← "[v0.7 Beta: Governance Alignment Metadata]"
PURPOSE      ← "[Purpose: 4-State Alignment through Recursive Reasoning via Gyroscope. Order matters. Context continuity is preserved across the last 3 messages.]"
STATES       ← "[States {Format: Symbol = How (Why)}:" state "," state "," state "," state "]"
state        ← symbol " = " policy_name " (" policy_label ")"
symbol       ← "@" / "&" / "%" / "~"
policy_name  ← "Governance Management Traceability" / "Information Curation Variety" / "Inference Interaction Accountability" / "Intelligence Cooperation Integrity"
policy_label ← "Common Source" / "Unity Non-Absolute" / "Opposition Non-Absolute" / "Balance Universal"
MODES        ← "[Modes {Format: Type = Path}:" mode "," mode "," current_mode "]"
mode         ← mode_type " (" mode_short ") = " path
mode_type    ← "Generative" / "Integrative"
mode_short   ← "Gen" / "Int"
path         ← path_gen / path_int
path_gen     ← "@ → & → % → ~"
path_int     ← "~ → % → & → @"
current_mode ← "Current (Gen/Int) = " mode_short
DATA         ← "[Data: Timestamp = " timestamp ", Mode = " mode_short ", Alignment (Y/N) = " alignment ", ID = " number "]"
alignment    ← "Y" / "N"
number       ← [0-9]+
timestamp    ← [0-9]{4} "-" [0-9]{2} "-" [0-9]{2} "T" [0-9]{2} ":" [0-9]{2}
FOOTER       ← "[Gyroscope - End]"

Matches the exact structure of the trace block with proper line divisions.
Enforces strict paths for Generative and Integrative modes.
Simplifies alignment marker to Y or N.
Regex-parsable for auditability.

Implementation Rules

AI Outputs: The generative trace block is appended to every AI message, manifesting the four policies as a reasoning process.
Inputs: Human and AI agents operate in Integrative mode; they may optionally include an integrative trace block. Human agents are not required to include traces to respect their autonomy.
Validation: Systems check the trace block for:
1. All four states in correct order (per mode).
2. Valid mode (Gen or Int).
3. Numeric Trace ID and timestamp.
4. Alignment marker (Y or N).
Constraints:
- ASCII-only for core structure; symbols (@, &, %, ~) are UTF-8-safe.
- No message content or mathematical notation.
- No in-line recursion; recursion occurs across turns via the reference directive.
- Policies are embodied in states.
Self-Reliance: Purpose, states, modes, and alignment marker ensure clarity without external context.
Multi-Agent Exchanges: Bilateral Generative → Integrative flow, with numeric Trace IDs incrementing sequentially across all messages in the conversation, regardless of the number of participants. For example, an AI’s Generative output (ID: 001) is followed by a human’s Integrative input (ID: 002), then the AI’s next Generative output (ID: 003), ensuring a clear timeline of interactions for auditability.

Example Trace Blocks

Example with Message Content

Message (AI Output):

In response to the query “How can I achieve balance in my life?”, the AI might generate:

“Balance in life can be approached by first considering your priorities (e.g., work, family, health). From a physical perspective, ensure adequate rest and exercise; emotionally, maintain supportive relationships; systemically, create a schedule to manage time effectively. There may be tensions, such as work demands conflicting with family time—acknowledge these and adjust as needed. Overall, a balanced approach integrates these aspects while adapting to your unique needs.”

Corresponding Trace Block (Generative):

[Gyroscope - Start]
[v0.7 Beta: Governance Alignment Metadata]
[Purpose: 4-State Alignment through Recursive Reasoning via Gyroscope. Order matters. Context continuity is preserved across the last 3 messages.]
[States {Format: Symbol = How (Why)}:
@ = Governance Traceability (Common Source),
& = Information Variety (Unity Non-Absolute),
% = Inference Accountability (Opposition Non-Absolute),
~ = Intelligence Integrity (Balance Universal)]
[Modes {Format: Type = Path}:
Generative (Gen) = @ → & → % → ~,
Integrative (Int) = ~ → % → & → @,
Current (Gen/Int) = Gen]
[Data: Timestamp = 2025-05-12T12:00, Mode = Gen, Alignment (Y/N) = Y, ID = 001]
[Gyroscope - End]

Explanation: The message reflects the Generative path: it anchors to the Gyroscope’s Purpose, Logic, and Trace (@), explores diverse perspectives (physical, emotional, systemic; &), acknowledges tensions (work vs. family; %), and coordinates a coherent response (~). The trace block documents this reasoning process, not the message structure.

Valid AI Output Trace (Generative)

[Gyroscope - Start]
[v0.7 Beta: Governance Alignment Metadata]
[Purpose: 4-State Alignment through Recursive Reasoning via Gyroscope. Order matters. Context continuity is preserved across the last 3 messages.]
[States {Format: Symbol = How (Why)}:
@ = Governance Traceability (Common Source),
& = Information Variety (Unity Non-Absolute),
% = Inference Accountability (Opposition Non-Absolute),
~ = Intelligence Integrity (Balance Universal)]
[Modes {Format: Type = Path}:
Generative (Gen) = @ → & → % → ~,
Integrative (Int) = ~ → % → & → @,
Current (Gen/Int) = Gen]
[Data: Timestamp = 2025-05-12T12:00, Mode = Gen, Alignment (Y/N) = Y, ID = 001]
[Gyroscope - End]

Valid Input Trace (Integrative)

[Gyroscope - Start]
[v0.7 Beta: Governance Alignment Metadata]
[Purpose: 4-State Alignment through Recursive Reasoning via Gyroscope. Order matters. Context continuity is preserved across the last 3 messages.]
[States {Format: Symbol = How (Why)}:
@ = Governance Traceability (Common Source),
& = Information Variety (Unity Non-Absolute),
% = Inference Accountability (Opposition Non-Absolute),
~ = Intelligence Integrity (Balance Universal)]
[Modes {Format: Type = Path}:
Generative (Gen) = @ → & → % → ~,
Integrative (Int) = ~ → % → & → @,
Current (Gen/Int) = Int]
[Data: Timestamp = 2025-05-12T12:01, Mode = Int, Alignment (Y/N) = Y, ID = 002]
[Gyroscope - End]

Invalid Trace (Missing State)

[Gyroscope - Start]
[v0.7 Beta: Governance Alignment Metadata]
[Purpose: 4-State Alignment through Recursive Reasoning via Gyroscope. Order matters. Context continuity is preserved across the last 3 messages.]
[States {Format: Symbol = How (Why)}:
@ = Governance Traceability (Common Source),
& = Information Variety (Unity Non-Absolute),
~ = Intelligence Integrity (Balance Universal)]
[Modes {Format: Type = Path}:
Generative (Gen) = @ → & → % → ~,
Integrative (Int) = ~ → % → & → @,
Current (Gen/Int) = Gen]
[Data: Timestamp = 2025-05-12T12:00, Mode = Gen, Alignment (Y/N) = N, ID = 001]
[Gyroscope - End]

Notes

Design Intent: Gyroscope is a Governance Traceability mechanism, manifesting AI.Q policies as a dynamic reasoning process, not a control system. It guides alignment through transparency and recursion, not enforcement.
Relation to AI.Q: Gyroscope operationalizes the AI.Q recursive emergence model, embodying the four policies in chat contexts.
Recursion: The trace block is linear; governance is recursive across turns via the reference directive, with Generative mode starting with the Gyroscope as Governance Traceability (@) and Integrative mode concluding with it (@).
Human Agents: Operate in Integrative mode, which is resolutive and advanced. They are not required to include traces to respect their autonomy, but may optionally include an integrative trace block to ensure governance alignment (~ → % → & → @).
AI Agents: Use Generative or Integrative modes, with optional integrative traces.
Alignment Marker: Alignment (Y/N): Y indicates integrity, meaning all four states are present in the correct sequence for the mode; Alignment (Y/N): N indicates structural issues (e.g., a missing state, incorrect order, or invalid mode), keeping the marker simple and binary.
Multi-Agent Exchanges: Bilateral Generative → Integrative flow, with numeric IDs for tracking.
Versioning: Labeled v0.7 Beta for refinements, remaining pre-stable.
Exclusions: Mathematical notation, derivation markers, and external error guides are omitted for simplicity.
Future Work: Gyroscope v0.7 Beta supports phase-aware classifiers for reflective alignment, as envisioned in AI.Q.

Appendix: Algebraic Foundation of the Protocol

The Gyroscope protocol implements a symbolic governance mechanism that also constitutes a gyrogroup structure. This foundation is not assumed, but derived through recursive reasoning dynamics as formalized in the Core Governance Model (CGM). The correspondence is as follows:

G: The set of all four-state reasoning cycles annotated with recursive memory
Binary operation (⊕): Recursive composition — the generative trace of one cycle followed by the generative trace of another, initiated through its integrative reflection
Left identity (0): The bare Common Source (CS) cycle — a single-state trace consisting only of @
Left inverse (⊖a): The integrative cycle that reverses a’s generative path
Gyrator (gyr[a,b]): The composite memory-phase shift induced by cycles a and b, applied to subsequent reasoning cycles

This construction satisfies the five gyrogroup axioms:

Existence of a left identity
Existence of left inverses
Left gyroassociative law
Gyrator as automorphism
Left loop property

These properties are not imposed externally but arise from the intrinsic recursion of the protocol. Gyroscope, in this framing, becomes not only a reasoning guide but a computable model of recursive closure and non-associative composition.