ADR-014: Ciphered Reasoning Loop

Status: Accepted Version: 1.0 Date: 2025-12-21 Supersedes: N/A Related ADRs: ADR-003, ADR-013 Related PRDs: N/A

Context

SEA-Forge™ requires a formal model for how AI agents can perform multi-step reasoning while preserving semantic correctness. The core problem is that LLMs operate in “semantic continuity space” (preserving plausibility) rather than “invariant space” (preserving truth). This leads to:

Multi-step math failures
Chain-of-thought collapse
Agents contradicting earlier decisions
Explanations that don’t round-trip back to formal truth

We need an architectural pattern that treats reasoning as invariant-preserving transformation across representations, not as token generation.

Decision

Adopt the Ciphered Reasoning Loop (CRL) as the canonical pattern for governed reasoning in SEA-Forge™.

Definition

A Ciphered Reasoning Loop is a reversible, invariant-preserving transcompiler between representations:

Encode → Validate → Operate → Re-validate → Decode → Round-trip Check → Commit

Core Components

Representations (the “cipher alphabets”)

F (Formal): AST / typed expressions / proof steps
G (Graph): Knowledge Graph nodes, relations, provenance
N (Natural Language): Rhetorical explanation with step citations
A (Agent Trace): Tool calls, intermediate artifacts, decisions

Invariant Contract

An invariant is a predicate that must remain true across allowed transforms:

Type	Description	Example
I₁ Identity	Symbols/variables refer consistently	α-equivalence allowed, capture not
I₂ Domain	Side-conditions preserved	Cancel f(x) → obligation f(x) ≠ 0
I₃ Equivalence	Transformations preserve semantics	Equality, implication
I₄ Dependency	Each step cites prerequisites	No “magic” leaps
I₅ Reversibility Budget	What is allowed to be lossy	Rhetoric style, not structure

Cipher Transform

A transform is an encoder/decoder pair with explicit validation:

E_{X→Y} — Encoder from representation X to Y
D_{Y→X} — Decoder from representation Y to X
V_I — Validator that checks invariants

The Loop Execution

Encode: Choose target representation Y := E_{X→Y}(X)
Validate: Enforce invariants assert V_I(Y)
Operate: Do work in that representation (LLM step, tool, agent, rewrite) Y' := Op(Y)
Re-validate: assert V_I(Y')
Decode (round-trip): X' := D_{Y→X}(Y')
Round-trip check: assert Equiv_I(X, X') over promised invariants
Commit: Store provenance + deltas in Knowledge Graph

Key Insight

The “cipher key” is the invariant set.
Invariants are literally governance policies that force meaning to survive representation changes.

Rationale

What This Changes

Dimension	Before CRL	With CRL
Meaning	Implicit in text	Explicit, externalized
Correctness	Emergent	Enforced by invariants
Reasoning	Linear (token sequence)	Transformational (governed)
Explanation	Narrative	Proof-carrying
Agents	Autonomous guessers	Interpreters of state
Drift	Undetected	Detectable + localizable

Core Implication: Reasoning Becomes Reversible

With invariants declared, every transformation must satisfy:

Encode → Decode → Validate

This gives:

Reversibility — Can reconstruct formal truth from explanation
Auditability — Every step has witnesses
Local failure diagnosis — “Which invariant failed, and at which transformation?”

Instead of asking “Why did the model hallucinate?”, we ask “Which invariant failed, and at which step?”

Why This Is Not Just Formal Methods

Existing approaches are partial ancestors:

Type systems
Model checking
Formal methods
Graph constraints

But none combine:

Multi-representation reasoning
Human + machine co-interpretation
Agent workflows
Continuous projection
Semantic governance
Round-trip validation

The novelty is the unified invariant-first worldview applied across math, language, agents, and architecture.

Alternatives Considered

Prompt Engineering for Correctness

Rejected — LLMs cannot reliably track invariant obligations across steps through prompting alone.

Pure Formal Verification

Rejected — Too rigid for human-AI co-creation; does not support natural language as a representation.

Chain-of-Thought Without External State

Rejected — CoT collapses because invariants are not externalized; each token is locally coherent but not globally obligated.

Constraints

MUST use Ciphered Reasoning Loop for governed multi-step reasoning
MUST externalize invariant state outside LLM token streams
MUST validate invariants at each transformation step
MUST support round-trip checks between representations
MUST commit provenance and deltas to Knowledge Graph
MUST NOT rely on Chain-of-Thought alone for correctness

Quality Attributes

LLMs become semantic interpreters, not reasoners
Hallucination becomes an invariant violation, not a mystery
Agent safety without neutering capability
Explanations become proof-carrying projections
Localized, actionable failure diagnostics

Bounded Contexts Impacted

Semantic Core
Knowledge Layer
AI Agent Runtime
Invariant Regime

Consequences

Positive

LLMs become semantic interpreters, not reasoners
Hallucination becomes an invariant violation, not a mystery
Agent safety without neutering capability
Explanations become proof-carrying projections
Localized, actionable failure diagnostics

Negative

Requires explicit invariant declaration upfront
Needs tooling for step schemas, obligation tracking, witnesses
Small invariants (few, explicit, testable) work best; over-modeling kills flexibility

Additional Notes

Implementation Guidance

Biggest Risk: Over-Modeling

If you try to:

Encode every nuance
Freeze semantics too early
Treat invariants as metaphysical truths

…you’ll kill flexibility.

Winning posture:

Small, strong invariants
Explicitly declared loss budgets
Evolution via versioned semantics

Invariants should be few, explicit, and testable — not philosophical.

REF-012: Invariant Regime Specification
SDS-006: Softmax Router Multi-Agent Pattern

⏳ Post-MVP (advanced reasoning pattern)