Manifestation
Manifestation is the process of going from specification to running system. It encompasses all intermediate steps: planning, designing, coding, building, testing, and deploying.
In the intended workflow, the same AI-agent ecosystem both:
- maintains the spec graph (through graph-aware tools such as MCP), and
- manifests the system from that graph.
Humans keep strategic control; agents perform structured execution.
Spec Graph → [Manifest] → Running System
G A M
Where:
- G = the spec graph
- A = the implementing agent (or team of agents)
- M = the manifested system
The Manifestation Property
When a spec graph is complete and the implementing agent is capable:
Complete(G) ∧ Capable(A) → Predictable(Manifest(G, A))
This means: the same graph, processed by the same (or equivalent) agent, always produces logically equivalent systems. Perfect determinism — identical output every time — is the idealistic limit; predictability across all specified dimensions is the practical achievement.
What "Capable" Means
A capable implementing agent can:
- Parse the spec graph — load
graph.json, resolve all node references - Traverse the graph — follow edges, resolve dependencies
- Apply guidance — implement according to decision nodes
- Respect constraints — verify non-functional requirements
- Verify outcomes — run each node's verification criteria
Conceptual Phases
The manifestation process has three conceptual phases:
| Phase | Input | Output | Activity |
|---|---|---|---|
| Orient | All nodes | System understanding | Read and comprehend the full graph |
| Scaffold | Decision + domain nodes | Infrastructure | Create architecture, abstractions, shared code |
| Implement | Behavior nodes + context | Working features | Build each behavior with full graph context |
These phases are described in detail in Orient, Scaffold, Implement.
Not a Rigid Pipeline
The three phases are conceptual, not prescriptive steps. A capable agent might:
- Process phases iteratively rather than sequentially
- Interleave scaffold and implement work
- Revisit earlier phases when new information emerges
What matters is the outcome: the manifested system satisfies all nodes in the graph. The phases describe the natural ordering of information, not a mandatory workflow.
Manifestation vs. Task Derivation
The spec graph is a specification, not a task list. The mapping from graph to tasks is determined by the agent's planning phase:
- Each approved behavior node typically yields one implementation task
- Decision nodes may yield infrastructure/setup tasks
- Constraint nodes yield verification tasks
- Domain nodes inform all tasks but may not generate their own
The specific task derivation strategy is an agent concern, not a spec graph concern. Different agents may derive different task orderings while producing equivalent results.