Introduction
Manifesto computes deterministic domain state transitions.
Manifesto is a lightweight domain runtime. You write domain transition rules in MEL, run them through the runtime, and expose the same typed actions and Snapshots to frontend code, backend services, and agents.
MEL -> Core -> Host
rules compute executeMEL declares domain transition rules. Core computes semantic transitions from schema, snapshot, intent, and context. Host fulfills declared effects and converges snapshots.
The SDK is the application-facing surface most projects use first: createManifesto() -> activate() -> action.<name>.submit() -> snapshot().
Lineage and Governance are optional protocol extensions for applications that need history, restore, audit, approval, policy, or delegation. They are not prerequisites for a first app.
It is not a state management library, an AI framework, a database, or a workflow engine. It is the domain runtime underneath those surfaces.
Why Manifesto?
Deterministic by design
Domain rules are pure. External work is declared explicitly. Given the same domain, current snapshot, and action input, Manifesto computes the same next snapshot.
Frontend, backend, and agents
UI components, server routes, scripts, jobs, and agents can all submit actions against the same domain model.
You do not need one state contract for UI, another for automation, and another for audit.
One app state
Submit an action, then read the updated app state. Effect results come back through the same state model instead of a second side channel.
That keeps the visible result in one place.
The Base Runtime Path
In application code, start here:
MEL domain -> createManifesto() -> activate() -> action.<name>.submit() -> SnapshotThe base SDK runtime is the normal app path. It is the right default for learning, UI integration, backend routes, scripts, and trusted agent tools.
Two Tracks, One Domain
The docs use two tracks on purpose:
| Track | Use It For | What Comes Next |
|---|---|---|
| No-build learning | Quick Start and the first Todo tutorials | Learn MEL, createManifesto(), submit(), and snapshot() with the Node/tsx loader |
| Typed app building | React, server routes, and agent tools | Add Bundler Setup and Code Generation so app code imports the generated TodoDomain facade |
Do not carry the tutorial's small local TypeScript shapes into a real web or agent app. Once more than one app file needs domain types, use the generated facade from the same .mel file.
Learning Path
Follow this order when you are new to Manifesto:
| Step | Read | You Can Do Afterward |
|---|---|---|
| 1 | Quick Start | Run one MEL domain through the SDK runtime |
| 2 | Project Anatomy | Know where the domain, runtime, UI, and agent files live |
| 3 | MEL Domain Basics, MEL For App Developers, then Creating an App | Model state, computed values, actions, and the app runtime |
| 4 | Tutorial | Build a small Todo app without a UI framework |
| 5 | Bundler Setup and Code Generation | Use the generated Todo facade from the same .mel file |
| 6 | React and Runnable Examples | Connect that app model to a web UI and compare with a working app |
| 7 | Web App + Agent | Put the UI and agent behind one shared server runtime |
| 8 | AI Agents | Go deeper on agent-only tool loops and server workers |
| 9 | When You Need Approval or History | Decide whether review or history belongs in the product |
You do not need low-level package APIs to build the first web app or trusted agent integration. Open those pages when you are building custom runtime tooling or adding reviewable history.
Learning Checkpoints
Move forward when the current checkpoint is true:
| Checkpoint | Done When |
|---|---|
| Quick Start | counter.mel runs and snapshot().state.count prints 1 |
| Todo domain | src/domain/todo.mel has add, toggle, remove, filter, and clear actions |
| Generated facade | src/domain/todo.domain.ts exists and exports TodoDomain |
| React UI | the browser can add, toggle, filter, remove, and clear todos |
| UI + agent | React fetch helpers and agent tools call the same server-side action functions |
Choose The Next Page By Goal
| Goal | Read |
|---|---|
| I want the smallest running thing | Quick Start |
| I want to know where files go | Project Anatomy |
| I want to run an existing example | Runnable Examples |
| I want to understand the domain file | MEL Domain Basics |
| I want the minimum MEL syntax for an app | MEL For App Developers |
| I want a small app before a framework | Tutorial |
I want to import .mel files in my app | Bundler Setup |
| I want TypeScript types from my domain | Code Generation |
| I want browser UI wiring | React |
| I want one UI and one agent sharing state | Web App + Agent |
| I want a deeper agent-only tool loop | AI Agents |
Stay on the shortest path that matches the product you are building. You can skip concepts, architecture, API reference, and approval/history until a page above points you there.
Add Approval Or History Later
When writes need review, actor identity, durable history, or audit queries, add those layers around the same app model. They are not prerequisites for your first app.
Next
Start with Quick Start, then skim Project Anatomy. Continue through MEL Domain Basics, MEL For App Developers, and Creating an App. Use Runnable Examples after React when you want to compare your app with a finished version.