超越以代理為中心的設計：AI 的世界為中心協調

Forem Feed

DEV Community

A space to discuss and keep up software development and manage your software career

Future

News and discussion of science and technology such as AI, VR, cryptocurrency, quantum computing, and more.

Open Forem

A general discussion space for the Forem community. If it doesn't have a home elsewhere, it belongs here

Gamers Forem

An inclusive community for gaming enthusiasts

Music Forem

From composing and gigging to gear, hot music takes, and everything in between.

Vibe Coding Forem

Discussing AI software development, and showing off what we're building.

Popcorn Movies and TV

Movie and TV enthusiasm, criticism and everything in-between.

DUMB DEV Community

Memes and software development shitposting

Design Community

Web design, graphic design and everything in-between

Security Forem

Your central hub for all things security. From ethical hacking and CTFs to GRC and career development, for beginners and pros alike

Golf Forem

A community of golfers and golfing enthusiasts

Crypto Forem

A collaborative community for all things Crypto—from Bitcoin to protocol development and DeFi to NFTs and market analysis.

Parenting

A place for parents to the share the joys, challenges, and wisdom that come from raising kids. We're here for them and for each other.

Forem Core

Discussing the core forem open source software project — features, bugs, performance, self-hosting.

Maker Forem

A community for makers, hobbyists, and professionals to discuss Arduino, Raspberry Pi, 3D printing, and much more.

HMPL.js Forem

For developers using HMPL.js to build fast, lightweight web apps. A space to share projects, ask questions, and discuss server-driven templating

DEV Community

Posted on Jan 9

The Mind Protocol: Why Your AI Agent Needs a World Before It Can Think

🧪 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:

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:

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:

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:

This is the minimal structure for trustworthy agency.

The Projection Formula

React revolutionized UI with a simple formula:

Same state, same UI. Always. The Mind Protocol generalizes this:

Where Projection is any derived output:

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."

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:

A World does the same for your domain:

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:

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.

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.

The Mind has:

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:

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:

This means:

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:

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:

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:

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:

During rebound:

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:

This captures "what matters right now"—recent topics, active concerns, current focus.

Semantic Memory (Knowledge Graph)

Triple-based factual storage:

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:

Learning without governance is dangerous. An Actor that freely updates its knowledge could:

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.

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

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)

Templates let you quickly answer FAQs or store snippets for re-use.

Are you sure you want to hide this comment? It will become hidden in your post, but will still be visible via the comment's permalink.

Hide child comments as well

Confirm

For further actions, you may consider blocking this person and/or reporting abuse

More from Jung Sungwoo

💎 DEV Diamond Sponsors

Thank you to our Diamond Sponsors for supporting the DEV Community

Google AI is the official AI Model and Platform Partner of DEV

Neon is the official database partner of DEV

Algolia is the official search partner of DEV

DEV Community — A space to discuss and keep up software development and manage your software career

Built on Forem — the open source software that powers DEV and other inclusive communities.

Made with love and Ruby on Rails. DEV Community © 2016 - 2026.

We're a place where coders share, stay up-to-date and grow their careers.