I built Branch Forge Story OS, a filesystem-based assistant for writing and managing stories non-linearly.
Instead of treating a story as a linear document, it models story knowledge as a filesystem:
scenes, characters, rules, and constraints are nodes
navigation happens via paths, not scrolling
invariants (canon, tone, social rules) are enforced explicitly
changes are localized (patches don’t ripple unless requested)
The goal is to support long, complex narratives without re-reading or losing consistency. You can write scenes out of order, branch timelines, and mount only the parts of the story relevant to the current operation.
This started as an experiment in applying systems design ideas (filesystems, invariants, mounts, diffs) to narrative writing. I’m curious how people here think about non-linear authorship, constraint enforcement, and whether this model generalizes beyond fiction.
Reversible Binary Explainer: Proving Directive-Locked AI Explanations with MindsEye
Part of the MindsEye Series — Auditable, Reversible Intelligence Systems
Modern AI explainers are good at talking about concepts.
They are far less good at proving correctness, enforcing structure, or maintaining reversibility.
This post introduces Reversible Binary Explainer, a directive-locked explainer system designed to enforce deterministic structure, reversible logic, and verifiable execution across binary operations, encoding schemes, memory layouts, algorithm traces, and mathematical transformations — all within the MindsEye ecosystem.
What makes this system different is simple but strict:
The explainer is not allowed to “explain” unless it can prove the explanation can be reversed.
Why Reversible Binary Explainer Exists
Most technical explanations fail silently in three ways:
They mix structure and prose unpredictably
They claim reversibility without validating it
They cannot be audited after the fact
Reversible Binary Explainer addresses this by operating in DIRECTIVE MODE v2.0, where:
Every explanation must use a locked template
Every transformation must show forward and inverse logic
Every step must include MindsEye temporal, ledger, and network context
Any deviation is rejected by the system itself
This turns explanations into verifiable artifacts, not just text.
The Template System (A–E)
The system operates on five directive-locked templates:
Template A — Binary Operations Explainer
Bitwise operations with mandatory inverse reconstruction
Template B — Encoding Scheme Breakdown
Encoding and decoding paths with strict round-trip verification
Template C — Memory Layout Visualization
Pack/unpack guarantees with alignment, endianness, and byte-level recovery
Template D — Algorithm Execution Trace
Step-indexed execution with stored artifacts for backward reconstruction
Template E — Mathematical Operation Breakdown
Explicit forward and inverse math, numeric representation, edge cases, and code
Each template starts LOCKED.
Structure cannot be altered unless explicitly unlocked by command.
Directive Commands and Enforcement
The explainer only responds to deterministic commands:
SHOW TEMPLATES
USE TEMPLATE [A–E]
UNLOCK TEMPLATE [A–E]
SHOW DEPENDENCIES
VERIFY REVERSIBILITY
GENERATE SNAPSHOT
FREEZE ALL
If:
no template is selected
structure edits are attempted while locked
reversibility cannot be verified
the system rejects the request.
This makes the explainer self-policing.
MindsEye Integration
Every explanation is automatically wired into three MindsEye layers:
Temporal Layer
Each step is time-labeled, enabling ordered replay and causal tracing.
Ledger Layer
Every transformation emits a content-addressed provenance record:
operation ID
previous hash
step hash
reversibility flag
Network Layer (LAW-N)
Payload descriptors declare:
content type
bit width
endianness
schema ID
reversibility guarantees
This allows explanations to be routed, validated, and stored as first-class system events.
I built a live explorer for a ledger-first AI system where every prompt, decision, tool call, and outcome is recorded immutably and can be replayed.
Instead of overwriting prompts or treating LLM calls as ephemeral, MindsEye stores AI cognition as an append-only ledger. You can inspect how prompts evolve (Prompt Evolution Tree), trace decisions end-to-end, and audit why an action happened — or prove that it didn’t.
This is part of a broader experiment in “ledger-first cognition”: moving AI systems from stateless calls to accountable, stateful organizational memory.
Happy to answer questions or go deep on the architecture.
Instead of treating a story as a linear document, it models story knowledge as a filesystem:
scenes, characters, rules, and constraints are nodes
navigation happens via paths, not scrolling
invariants (canon, tone, social rules) are enforced explicitly
changes are localized (patches don’t ripple unless requested)
The goal is to support long, complex narratives without re-reading or losing consistency. You can write scenes out of order, branch timelines, and mount only the parts of the story relevant to the current operation.
This started as an experiment in applying systems design ideas (filesystems, invariants, mounts, diffs) to narrative writing. I’m curious how people here think about non-linear authorship, constraint enforcement, and whether this model generalizes beyond fiction.
Feedback welcome.
reply