What is Manifesto?
Purpose: Introduction and navigation for understanding Manifesto Audience: Anyone new to Manifesto Reading time: 2 minutes
Overview
This section answers the fundamental question: What is Manifesto and why should I care?
Manifesto is a semantic state layer for building AI-governed applications with deterministic computation and full accountability. But what does that mean? Why does it exist? When should you use it?
This section provides multiple entry points depending on your background and needs.
What You'll Learn
Quick Understanding
If you want to quickly grasp what Manifesto is and whether it's relevant to you:
Start here:
- One-Sentence Definitions — Manifesto explained for your specific role (3 min)
- The Problem Manifesto Solves — What problems drive Manifesto's design (10 min)
- Manifesto vs. Others — How it compares to Redux, XState, Event Sourcing, etc. (15 min)
Deep Understanding
If you want to understand the philosophy and architecture:
Continue to:
- Core Concepts — Snapshot, Intent, Effect, Flow, World
- Architecture Overview — Layered design and data flow
- Design Rationale — Why things are the way they are
Recommended Reading Order
Path 1: Evaluator (15 minutes)
Goal: Decide if Manifesto is right for your project
- One-Sentence Definitions — Find your role, read that section
- The Problem Manifesto Solves — Read "The Three Core Problems" and "Who Should Use Manifesto"
- Manifesto vs. Others — Compare with tools you know
Decision point: If Manifesto seems like a good fit, proceed to Path 2. Otherwise, you've saved time learning this isn't what you need.
Path 2: Builder (1 hour)
Goal: Build your first Manifesto application
- Getting Started — Follow the tutorial
- Todo Example — See a complete application
- Core Concepts — Understand Snapshot, Intent, Effect, Flow
Outcome: You can build basic Manifesto applications.
Path 3: Expert (4+ hours)
Goal: Master Manifesto's architecture and capabilities
- Architecture — Understand the six layers
- Specifications — Read normative contracts
- Design Rationale — Understand why decisions were made
- Advanced guides: Re-entry Safe Flows, Effect Handlers
Outcome: You can design complex systems with Manifesto and contribute to the project.
Pages in This Section
One-Sentence Definitions
Quick, role-specific explanations:
- For software developers
- For AI researchers
- For product managers
- For technical leaders
- Plus analogies ("Git for application state", "Constitution for your app")
When to read: You want a quick understanding tailored to your background.
The Problem Manifesto Solves
Deep dive into the three core problems:
- Unpredictability — Non-deterministic behavior, hidden state
- Unaccountability — No audit trail, can't answer "who/why"
- Untestability — Requires mocks, brittle tests
Plus: How Manifesto solves them, real-world scenarios, decision tree.
When to read: You want to understand the motivation and see if your problems match.
Manifesto vs. Others
Detailed comparisons with:
- Redux (state management)
- Zustand (lightweight state)
- MobX (reactive state)
- XState (finite state machines)
- Event Sourcing (event-driven architecture)
- Workflow orchestrators (Temporal, Airflow)
When to read: You're familiar with other tools and want to understand how Manifesto differs.
Key Concepts (Quick Reference)
If you just need a cheat sheet:
| Concept | One-Liner | Learn More |
|---|---|---|
| Manifesto | Semantic state layer with deterministic computation and governance | Problem |
| Core | Pure semantic calculator (no IO) | Core Concepts |
| Host | Effect executor (handles IO) | Host Concept |
| World | Governance layer (authority + audit) | World Concept |
| Snapshot | Complete state at a point in time | Snapshot Concept |
| Intent | Request to perform an action | Intent Concept |
| Flow | Declarative computation (data, not code) | Flow Concept |
| Effect | Declaration of external operation | Effect Concept |
Frequently Asked Questions
Is Manifesto a state manager like Redux?
Partially. Manifesto provides state management, but adds:
- Governance (World Protocol for authority)
- Determinism (guaranteed same input → same output)
- Accountability (built-in audit trails)
- AI-native (schemas are JSON, perfect for LLM generation)
See Manifesto vs. Redux for details.
Do I need AI to use Manifesto?
No. The governance, determinism, and accountability features are valuable for any application. AI governance is one use case, not a requirement.
Use Manifesto if you need:
- Deterministic computation
- Audit trails
- Complex domain logic
- Multi-actor authorization
Is this overkill for my simple app?
Probably yes. If you're building:
- Simple UI state management → Use
useStateor Zustand - Rapid prototype → Use Redux
- Small app with no governance → Use MobX
Manifesto is designed for complex domains where correctness, accountability, and determinism matter.
See Who Should Use Manifesto for decision tree.
How is this different from Event Sourcing?
Key difference: We store intents (proposals), not events (facts).
| Event Sourcing | Manifesto |
|---|---|
| Stores events | Stores intents + worlds |
| Rebuild state from events | Snapshot is source of truth |
| Event log is primary | Snapshot is primary |
| No built-in governance | World Protocol for authority |
See Manifesto vs. Event Sourcing for full comparison.
Can I use this with my existing stack?
Yes. Manifesto is a domain layer that integrates with:
- Frontend: React, Vue, Svelte (via Bridge)
- Backend: Express, FastAPI, any framework (via Host)
- Database: Postgres, MongoDB, any database (via effect handlers)
- AI: LangChain, AutoGPT, any agent framework (via World Protocol)
Manifesto doesn't replace your stack. It provides semantic state management.
Next Steps
If You're Just Starting
- Read One-Sentence Definitions for your role
- Skim The Problem to see if it resonates
- If interested, try Getting Started
If You're Evaluating
- Read The Problem completely
- Read Manifesto vs. Others for tools you know
- Check Specifications for technical depth
- Join our Discord to ask questions
If You're Ready to Build
- Follow Getting Started
- Build the Todo Example
- Explore Core Concepts
- Read advanced guides as needed
Get Help
- Discord: Join our community
- GitHub: Discussions
- Documentation: Guides and Architecture
Summary
What is Manifesto?
A semantic state layer that separates pure computation (Core) from execution (Host) and provides built-in governance (World), enabling deterministic, accountable, AI-safe applications.
Why does it exist?
Traditional state management mixes logic with effects, making systems non-deterministic, unaccountable, and untestable. Manifesto enforces separation of concerns.
Who should use it?
Applications needing deterministic computation, AI governance, audit trails, or complex domain logic.
Who shouldn't use it?
Simple UI state, rapid prototypes, or workflow orchestration use cases.
Ready to learn more?
Choose your path:
- Quick: One-Sentence Definitions
- Problem-focused: The Problem Manifesto Solves
- Comparison-focused: Manifesto vs. Others
- Hands-on: Getting Started