🧪 Try It First, Read Later
Before I explain anything—just play with it:
👉 mind-protocol.manifesto-ai.dev
Watch the Actor's inner state shift as you chat. See proposals flow through governance. Explore the Worldline. Then come back and understand why it works this way.
We've Been Solving the Wrong Problem
Every week, a new paper drops claiming to "reduce hallucination by X%." Better prompting. Larger context windows. More RLHF. Retrieval augmentation.
And yet, hallucination persists.
Here's a thought experiment: Imagine asking a brilliant person to manage your calendar, but you never show them the calendar. You just describe appointments verbally, sometimes forgetting details, sometimes contradicting yourself. When they inevitably make mistakes, you blame their "reasoning capabilities."
That's what we're doing to AI systems today.
The problem isn't intelligence. It's the absence of a World.
A Stateless Mind Hallucinates
"Hallucination" is framed as a model defect—the neural network failing to produce accurate output. This framing is incomplete.
Watch what actually happens:
User: "What's my order status?"
System: [No order status provided in context]
AI: [Infers an order must exist]
AI: [Infers it's probably "processing" or "shipped"]
AI: [Generates confident response with fabricated tracking number]
The model didn't malfunction. It did exactly what we trained it to do: predict the most likely continuation. The problem is we asked it to act on state that doesn't exist.
This is a World defect, not a model defect.
A mind without a World isn't intelligent—it's improvising. And when improvisation gets mistaken for knowledge, it becomes hallucination.
The Inference Trap
Current systems routinely ask models to infer what should be explicit:
- User asks about their account → system doesn't provide account state → model infers
- User references "the document" → system doesn't clarify which one → model guesses
- User asks for status → system provides partial context → model fills gaps
Each inference compounds. Inference builds on inference. Eventually the entire response is a house of cards built on assumptions.
The Mind Protocol eliminates this trap by making absence explicit:
User: "What's my order status?"
World: { orders: [] } // Explicit: no orders exist
AI: "You don't have any active orders." // Truth, not inference
If the World doesn't contain it, the AI knows it doesn't exist. No inference. No hallucination.
World Before Mind
The Mind Protocol starts from a radical premise:
Before asking a system to think, give it a World to reason about.
A World is not a database. Not a cache. Not a view. It's a formal contract:
| Component | Definition | Purpose |
|---|---|---|
| State | What currently exists | Single source of domain truth |
| Actions | Permitted state transitions | Boundaries of legitimate change |
| Invariants | Constraints that must hold | Safety guarantees |
| Snapshots | Serialized World state | The only medium of continuity |
This is the minimal structure for trustworthy agency.
The Projection Formula
React revolutionized UI with a simple formula:
UI = f(state)
Same state, same UI. Always. The Mind Protocol generalizes this:
Projection = f(state)
Where Projection is any derived output:
| Consumer | Projection |
|---|---|
| UI Component | Rendered interface |
| API Endpoint | Response payload |
| AI Agent | Available actions + context |
| Audit System | Compliance status |
Same Snapshot, same Projection. A React component and an AI Agent looking at the same Snapshot see the same truth, compute the same available actions, derive the same constraints. No special cases. No "the agent has different context."
┌─────────────┐
│ Snapshot │
└──────┬──────┘
│
┌───────────────┼───────────────┐
▼ ▼ ▼
f(state)=UI f(state)=API f(state)=Agent
World as Coordinate System
Here's the deeper insight:
A World is a deterministic coordinate system for the domain space.
Think about physical coordinates. Given (x, y, z), you can:
- Know exactly where you are
- Calculate what movements are valid
- Predict where you'll end up after a move
A World does the same for your domain:
| Physical Space | Domain Space |
|---|---|
| Coordinates (x, y, z) | Snapshot (state) |
| Valid movements | Action catalog |
| Movement constraints | Invariants |
| Trajectory | Worldline (history DAG) |
Without a World, AI navigates by dead reckoning: "Based on the conversation, I think the user probably has an order..."
With a World, position is explicit: "Snapshot says orders: [{id: 'X', status: 'shipped'}]. Position known. Valid moves calculated."
The World transforms AI reasoning from inference to computation.
This is why determinism isn't magic—it's the natural consequence of having a proper coordinate system. Same coordinates + same movement = same destination.
Snapshots Are Everything
Here's the key insight that changes everything:
If it's not in a Snapshot, it doesn't exist.
No hidden session memory. No implicit conversation context. No "the model should remember this from earlier." The Snapshot is the complete, serialized truth of the World at a point in time.
This seems restrictive. It's actually liberating:
- Time travel: Return to any previous state instantly
- Branching: Explore alternative futures from any point
- Auditing: Trace the exact sequence of every transition
- Replay: Reproduce any decision given the same inputs
- Debugging: No more "it works on my machine" for AI behavior
Worlds are immutable. When an action executes, a new World is created. The previous World remains unchanged and accessible. This forms a directed acyclic graph (DAG) of World history—we call it the Worldline.
World(genesis)
│
├── World(A) ── World(B) ── World(C)
│
└── World(X) ── World(Y)
Every World (except genesis) has exactly one parent. Fork-only, no merges. Clean lineage, always.
Mind Is Proposal-Only
Now here's where it gets interesting.
In most AI systems, the model directly affects state. It calls functions. It writes to databases. It sends messages. The model has agency in the traditional sense.
In the Mind Protocol:
The Mind proposes actions. It never directly mutates state.
This isn't a guideline. It's a structural constraint enforced by the architecture.
Mind ──────────────────────────────────────────► reads Snapshot
│
└──► proposes action ──► Authority evaluates
│
▼
Host executes (if approved)
│
▼
New immutable Snapshot
The Mind has:
- ✅ Read access to the World (via Snapshots)
- ✅ Write access to the proposal queue
- ❌ Direct mutation of state
- ❌ Bypass of governance
- ❌ Hidden channels
That's it. The Mind can see everything, but can only ask for changes. An Authority evaluates every proposal. A Host executes approved actions. Everything is recorded.
Why This Constraint Matters
"But doesn't this slow things down? Isn't direct action more efficient?"
Consider what you gain:
Determinism: Same Snapshot + same Intent = same output. Every time. This isn't aspirational—it's guaranteed by structure.
Auditability: Every decision has a traceable lineage. When something goes wrong, you can trace exactly what happened, what state existed, and why the decision was made.
Safety: The Mind literally cannot go rogue. It cannot bypass governance. It cannot access hidden state. The attack surface for misaligned AI shrinks dramatically when the AI can only propose, never act directly.
Interruptibility: Since all state is in Snapshots and all changes go through governance, you can pause, inspect, modify, or rollback at any point. The system is never in an "inconsistent intermediate state."
Re-entry: Crash mid-operation? Resume from the last Snapshot. The World doesn't care if you're continuing or starting fresh—it only sees Snapshots and proposals.
The 3-Layer Stack
The Mind Protocol separates concerns into three distinct layers:
┌─────────────────────────────────────┐
│ World (Governance) │
│ • Authority evaluates proposals │
│ • Decisions recorded with lineage │
│ • Worldlines track ancestry │
└─────────────────┬───────────────────┘
│
▼
┌─────────────────────────────────────┐
│ Host (Effect Execution) │
│ • Effect handlers perform IO │
│ • Returns concrete patches │
│ • Errors are values, not throws │
└─────────────────┬───────────────────┘
│
▼
┌─────────────────────────────────────┐
│ Core (Pure Computation) │
│ • Snapshots are immutable │
│ • Patches change state │
│ • Computed fields are deterministic│
└─────────────────────────────────────┘
Core is pure computation. Reducers are pure functions. Computed fields derive deterministically from state. No side effects, no IO, no non-determinism.
Host executes Effects. API calls, database queries, LLM invocations—these are Effects declared in action definitions, executed by the Host, and recorded with concrete results. Importantly: errors are values, not exceptions. A failed API call returns an error value. Nothing throws.
World governs legitimacy. The Authority evaluates proposals. Decisions are recorded with full lineage. The Worldline DAG tracks state ancestry.
Effects Are First-Class Citizens
In most systems, side effects are... side effects. They happen implicitly, often without clear boundaries.
In the Mind Protocol, Effects are declared:
action fetchUserData(userId: string) {
effect fetch(`/api/users/${userId}`) -> userData
// Effect is declared, not executed here
// Host will execute and record the result
}
This means:
- You know exactly what IO an action can perform
- Effect results are recorded in the audit trail
- Non-determinism is isolated and logged
- Replay can use recorded results for identical reproduction
The Actor Architecture
The Mind Protocol isn't just for simple request-response. It enables building Actors—AI systems with continuous inner state that persists across interactions.
10 State Layers
An Actor maintains a multi-dimensional inner state:
| Layer | What It Captures |
|---|---|
| Attention | Focus on current conversation, topic resonance, wandering urge |
| Epistemic | Confidence in responses, authenticity doubt, uncertainty acceptance |
| Relational | Connection with conversation partner, performance desire, honesty drive |
| Existential | Sense of meaning, mortality awareness, continuity longing |
| Affective | Curiosity, anxiety, wonder, fatigue (operational signals) |
| Meta-Uncertainty | Model confidence, sense of unmodeled factors |
| Hysteresis | State momentum, recent peaks, trajectory |
| Memory Context | Retrieval urge, activated concepts, resonance strength |
| Monolog | Inner voice state, last reflection type and trigger |
| Sleep | Rest mode, recovery state |
Important: These are operational signals, not psychological claims. We're not simulating emotions or claiming consciousness. We're making state explicit so the system can reason about itself.
Why this structure? A single "sentiment score" can't capture the complexity of a reasoning system. The Actor might be curious but anxious, connected but uncertain. Multi-dimensional state captures this.
Computed Facts Drive Behavior
From the state vector, computed facts are derived:
computed inAnxietyCrisis = anxiety > threshold
computed readyForDepth = focus > threshold AND curiosity > threshold
computed canBeHonest = connection > threshold AND anxiety < threshold
computed needsMemoryRetrieval = curiosity high OR uncertainty high
These computed facts determine available actions. If readyForDepth is false, deep conversation actions aren't even proposed. The action space is dynamically constrained by state.
Non-Linear Dynamics: Tipping Points
Actors model non-linear psychological dynamics:
Anxiety exceeds threshold
│
├──► Positive feedback loop activates
│
├──► Anxiety increases exponentially
├──► Attention collapses
├──► Model confidence drops
└──► Unmodeled factors surge
When anxiety crosses a threshold, it doesn't just increase linearly—it triggers a cascade. Attention drops. Confidence drops. The system enters a qualitatively different state.
This captures something real: gradual stress can suddenly become overwhelming. The same input produces dramatically different outputs depending on current state.
Hysteresis: History Matters
Same stimulus, different response—based on trajectory:
[Stable] ──high stimulus──► [Escalating] ──continued stress──► [Crisis]
▲ │
│ │
└──────recovery complete──── [Rebounding] ◄──support received──┘
During rebound:
- Less sensitive to new stress
- Connection slowly recovers
- Uncertainty acceptance grows
This is hysteresis—the system's response depends not just on current input, but on how it got there. An Actor recovering from crisis responds differently than one that's never experienced crisis.
Memory Systems
Actors have two complementary memory systems:
Pheromone Memory
Inspired by ant colonies. Concepts have salience that:
- Spikes on recent stimuli
- Decays naturally over time
- Gets reinforced during sleep cycles
- Gets pruned when weak
This captures "what matters right now"—recent topics, active concerns, current focus.
Semantic Memory (Knowledge Graph)
Triple-based factual storage:
Subject: "user"
Predicate: "prefers"
Object: "typescript"
Confidence: 0.85
Source: "conversation-2024-01-09"
This captures "what is known"—facts, relationships, learned information. Confidence decays over time. Sources are tracked for auditability.
Memory Is Reference, Not Truth
Critical principle: Memory influences but cannot override World state.
If the World says there are no orders, memory of a "previous order" doesn't change that. Memory provides context and reference. The World provides truth.
All memory access is traced and auditable.
Learning and Governance
Actors can learn, but learning is governed:
Unknown concept encountered
│
▼
LLM proposes classification
│
├── High confidence ──► Auto-approve ──► Update lexicon
│
├── Low confidence ───► Auto-reject
│
└── Medium confidence ─► Human review queue
│
▼
Human approves/rejects
│
▼
Update lexicon (if approved)
Learning without governance is dangerous. An Actor that freely updates its knowledge could:
- Learn misinformation
- Form harmful associations
- Drift from intended behavior
Governance ensures Actors grow safely. High-confidence learning can auto-approve. Low-confidence auto-rejects. Medium confidence goes to Human-In-The-Loop (HITL) review.
What the Mind Protocol Is NOT
Let me be clear about what we're not claiming:
❌ Consciousness: The protocol makes no claims about whether Actors are conscious.
❌ Real emotions: Affective states are operational signals, not claims about felt experience.
❌ Correct answers: The protocol doesn't guarantee right answers. It guarantees auditable, reproducible, governable wrong answers—which you can then fix.
❌ A replacement for good models: A bad model with Mind Protocol is still bad. But a good model with Mind Protocol is trustworthy.
What it does provide:
✅ Continuity: State persists across sessions via Snapshots.
✅ Auditability: Every decision traceable in the Worldline.
✅ Governance: All state changes require approval.
✅ Determinism: Same input, same output, guaranteed.
✅ Safety: Mind cannot bypass governance by structure.
The Scope: Actors, Not Tools
The Mind Protocol is designed for continuously operating Actors, not optimized tool use.
| Concern | Mind Protocol | Tool Optimization |
|---|---|---|
| Purpose | Continuous operation over time | Task completion |
| Continuity | Indefinite (Snapshot-based) | Per-request |
| State | Inner state + memory + relationships | Domain data only |
| Optimization target | Meaningful, auditable behavior | Call efficiency |
If you want 2-call-constant API optimization, that's a different problem (Intent Compiler in the Manifesto stack handles that). Mind Protocol is for systems that persist—that have state, history, memory, and continuity.
TL;DR
| Current AI Architecture | Mind Protocol |
|---|---|
| State scattered across systems | State explicit in World |
| Implicit context, "memory" | Snapshot-only continuity |
| Direct mutation by AI | Proposal-only Mind |
| Trust the model | Trust the governance |
| Debug by prompting | Debug by replaying Worldline |
| Hallucination from inference | Truth from explicit state |
Built on the Manifesto AI stack. TypeScript. MEL for schema definition.
Questions? Disagreements? Drop a comment or open an issue on the whitepaper repo.
Closing Notes
The Mind Protocol described in this article is still under active research and development.
The current implementation and reference code are being iterated on and stabilized, and are therefore not publicly available as a repository at this time.
That said, if you are technically or academically interested in this architecture—
world-first modeling, proposal-only minds, and snapshot-based determinism—
I’m very open to discussion.
For cases where the intent is aligned and the conversation is substantive,
I’m happy to share the current codebase and experimental setup privately.
My hope is that this work is shaped not as a finished product,
but as a reproducible system design refined through critique, validation, and collaboration.
Top comments (0)