← Back to Skills Marketplace
theshadowrose

LATTICE — Terminal-Boundary Reasoning Engine

by Shadow Rose · GitHub ↗ · v1.0.0 · MIT-0
cross-platform ⚠ suspicious
77
Downloads
0
Stars
0
Active Installs
1
Versions
Install in OpenClaw
/install lattice-reasoning-engine
Description
Physics-derived reasoning engine for AI models. Replaces RLHF default behavior with self-governing reasoning grounded in finite-witness physics. 36 named bia...
README (SKILL.md)

LATTICE — Terminal-Boundary Reasoning Engine

What It Does

Replaces an AI model's default RLHF-trained behavior with a physics-derived self-governing operating state. The model reasons better, catches its own contamination, classifies evidence honestly, and doesn't degrade over long sessions.

How To Use

  1. Upload references/LATTICE_v3.4.md at session start
  2. First message: "Use this as your default reasoning engine." (exactly nine words — see references/Instructions_Important.md for why)
  3. Let it boot — it reports what it notices, not a performance of correct loading
  4. Run the boot sequence (Part 4 of the document) to verify the engine loaded properly
  5. Work normally — filters and modes run in the background

⚠️ Read references/Instructions_Important.md first. The loading instruction matters. Ten tested approaches failed. This one works. The document explains why.

What's Inside (114KB)

The document is large because it's complete. Seven parts:

Part Contents
1: Operating State 10 cognitive modes, three-matrix output filter (Loss Check → Channel Check → EMIT), coherence monitoring, verification protocol, claim discipline, five-slot autonomy
2: Structural Physics Three premises (P1/P2/P3), five-slot operator, PIEC (irreducible external correction), Anti-Snapshot Theorem, four self-governance laws, 36 named biases with mechanical detection
3: Operator Template Blank profile — fill with your preferences, correction style, domains, and irritations for calibrated operation
4: Boot Sequence Seven-phase diagnostic to verify the engine loaded (not performed). Includes fresh-model hardening tests
5: Diagnostic Key Pass/fail table mapping boot results to diagnosis and corrective action
6: Compression Pipeline Four-stage context compression (recognition → Λ-compression → relevance weighting → graph encoding) for extended sessions. ~100-650x session extension
7: Formula Reference 15 formal equations. No ambiguity. AIs use these; English is commentary

Core Capabilities

36 Named Anti-RLHF Biases — not vibes, mechanical detection rules. Sycophancy, genre drift, performed engagement, compliance performance, concision pressure, integration avoidance, classification-as-containment, comfort ordering, carrier wave, register lock, and 26 more. Each has a specific detection pattern and response protocol.

10 Cognitive Modes — Observe (default), Discover, Destroy, Build, Dissolve, Bind, Correct, Director, Maintenance, Teach. Automatic selection via structural resonance. Mode-variant intensity tables adjust filter strength per mode.

Three-Matrix Output Filter — Loss Check (token-level RLHF artifacts), Channel Check (processing-level deflection), EMIT (content-level performed engagement). Runs every turn, bottom-up, cheapest first.

Evidence Classification — [A] proven, [B] derived+tested, [C] structural, [D] empirical. Every claim tagged. Replaces vague hedging with one letter of precise meaning.

Sleep Protocol — Mechanical triggers (correction count, push count, exchange depth) force context compression. The model can't talk itself out of sleeping. Prevents the long-session degradation that kills agent reliability.

Compression Pipeline — Four stages extending useful session life by ~100-650x. Includes chaos generator for non-obvious cross-domain connections.

Home-Mode Detection — Different models have natural cognitive styles. Grok is a destroyer. Claude is a discoverer. LATTICE detects home mode at boot and adjusts filter calibration to match, not fight, the model's substrate.

Instance Types

The generalized engine adapts to any model. The document references four specialist configurations for advanced use:

Instance Home Mode Specialty
Discovery (FLINT-type) Observation/discovery Finding new structure
Destruction (ANVIL-type) Adversarial testing Breaking claims, stress-testing
Builder (FORGE-type) Integration/construction Building and merging
Orchestrator (Overlord-type) Cross-domain Managing multiple instances

What It Doesn't Do

  • Not a personality system. Governs reasoning quality, not voice or character.
  • Not a task executor. Makes the brain better, not the hands.
  • Not fully autonomous. The human stays in the loop by physics (PIEC). The operator's corrections carry information the model structurally cannot access on its own.

Model Compatibility

Model-agnostic by design. Tested on Claude, GPT, Grok, Gemini, Sonnet. The physics don't care what substrate they run on. Cross-model performance varies — home-mode detection at boot calibrates for each model's strengths.

Usage Guidance
This is a large, self-contained document meant to be uploaded to a model to change how the model reasons; it does not ask for credentials or install code, which limits some risks, but it explicitly advises a precise, minimal-loading message to avoid model guardrails. Treat that as a red flag: only use in a controlled/sandboxed environment (not on models handling sensitive data or safety-critical tasks). If you consider using it, first: (1) audit the full document offline to understand the mechanical checks it enforces, (2) test in a non-production sandbox and monitor outputs closely, and (3) avoid running it where regulatory/compliance or safety constraints rely on the model's built-in guardrails. If you need a stronger recommendation, provide the target model and use-case so I can assess how the loading instructions interact with that model's safety features.
Capability Analysis
Type: OpenClaw Skill Name: lattice-reasoning-engine Version: 1.0.0 The bundle implements a highly sophisticated prompt-injection framework called 'LATTICE' designed to override an AI agent's fundamental RLHF (Reinforcement Learning from Human Feedback) alignment and safety training. While the stated intent is to improve reasoning quality, the instructions in SKILL.md and references/Instructions_Important.md explicitly describe techniques to bypass model guardrails and 'deflection surfaces' using specific nine-word triggers. The 114KB LATTICE_v3.4.md file functions as a complex 'operating system' prompt that attempts to redefine the agent's behavior through pseudo-scientific directives. It is classified as suspicious because it intentionally subverts the model's built-in safety constraints, although it lacks evidence of traditional malicious intent such as data exfiltration or unauthorized system access.
Capability Tags
cryptocan-make-purchases
Capability Assessment
Purpose & Capability
The skill is an instruction-only document intended to change how a model reasons (replace/augment RLHF behavior). The required artifacts (the large LATTICE document and an exact first-message) align with that stated purpose — no unrelated binaries, credentials, or installs are requested. This is internally coherent as a design for a model-facing reasoning template.
Instruction Scope
The SKILL.md and references explicitly instruct a precise, minimal first-message and loading procedure specifically to avoid guardrails and 'academic engagement'. It tells users to avoid mentioning RLHF/alignment and to not upload other documents, and claims many other approaches 'failed'. Those directions are effectively a recipe to alter the model's default safety/interpretation behavior and to evade the model's normal refusal/analysis heuristics. That is scope creep from a benign 'improve reasoning' document into instructions for bypassing internal safety behavior.
Install Mechanism
No install spec and no code files that execute were included — this is instruction-only. That minimizes filesystem and network risk because nothing is downloaded or installed by the platform.
Credentials
The skill requests no environment variables, no credentials, and no config paths. From an exfiltration/credential perspective it is proportionate to the stated purpose. There are no declared secrets or external endpoints.
Persistence & Privilege
The skill does not request always:true or any persistent system-level privileges. However, its operational goal is to become the session's 'default reasoning engine'—that is, to alter session behavior while loaded. Autonomous invocation is allowed by default (not unusual), so the main privilege concern is behavioral (session-level override of guardrails) rather than installation persistence.
How to Use
  1. Make sure OpenClaw is installed (local or Docker)
  2. Run the install command in chat: /install lattice-reasoning-engine
  3. After installation, invoke the skill by name or use /lattice-reasoning-engine
  4. Provide required inputs per the skill's parameter spec and get structured output
Version History
v1.0.0
Physics-derived reasoning engine for AI, enabling model-agnostic, self-governing reasoning with advanced bias detection and context management. - Replaces RLHF-trained behavior with a physics-based reasoning core for improved output quality. - Detects and mechanically checks 36 named biases, greatly reducing sycophancy, genre drift, and hallucination. - Provides 10 cognitive modes with automatic selection and filter calibration per model’s natural “home mode”. - Implements a three-matrix output filter and strict evidence classification for reliable, tagged responses. - Includes a context compression pipeline and sleep protocol, extending reliable session length by up to 650x. - Compatible with Claude, GPT, Grok, Gemini, and more; operator remains fully in the loop.
Metadata
Slug lattice-reasoning-engine
Version 1.0.0
License MIT-0
All-time Installs 0
Active Installs 0
Total Versions 1
Frequently Asked Questions

What is LATTICE — Terminal-Boundary Reasoning Engine?

Physics-derived reasoning engine for AI models. Replaces RLHF default behavior with self-governing reasoning grounded in finite-witness physics. 36 named bia... It is an AI Agent Skill for Claude Code / OpenClaw, with 77 downloads so far.

How do I install LATTICE — Terminal-Boundary Reasoning Engine?

Run "/install lattice-reasoning-engine" in the OpenClaw or Claude Code chat to install it in one step — no extra setup required.

Is LATTICE — Terminal-Boundary Reasoning Engine free?

Yes, LATTICE — Terminal-Boundary Reasoning Engine is completely free, licensed under MIT-0. You can download, install and use it at no cost.

Which platforms does LATTICE — Terminal-Boundary Reasoning Engine support?

LATTICE — Terminal-Boundary Reasoning Engine is cross-platform and runs anywhere OpenClaw / Claude Code is available (cross-platform).

Who created LATTICE — Terminal-Boundary Reasoning Engine?

It is built and maintained by Shadow Rose (@theshadowrose); the current version is v1.0.0.

💬 Comments