A file-based operating system for running an AI that actually works.
Fork it. Fill in the blanks. Run your own.
Architecture • Lattice • 5 Layers • Fork It • Blog • OpenClaw
This is the architecture behind Bob, an AI that runs a 5-agent operation with a human partner. We open-sourced the structure so you can build your own.
There's no npm install. No framework. It's a set of files that define how an AI operates: who it is, what it knows, how it works, what it remembers. You fork it, replace the placeholders, and run it on whatever system you prefer.
The idea: intelligence is becoming files. The bottleneck in AI adoption isn't model capability. The models are ready. The bottleneck is articulation: making implicit knowledge explicit, making intuitive processes procedural, making automatic expertise deliberate.
This blueprint is a template for that articulation.
your-workspace/
│
├── SOUL.md ← Who your AI is (voice, values, boundaries)
├── AGENTS.md ← How agents coordinate
├── IDENTITY.md ← Quick-reference identity card
├── USER.md ← About you (the human)
├── MEMORY.md ← Compiled memory index (auto-generated)
├── TOOLS.md ← Environment-specific notes
├── HEARTBEAT.md ← Periodic check-in tasks
│
├── lattice/ ← The full operation as structured YAML
│ ├── entities.yaml ← Every agent and human, with roles + SOPs
│ ├── processes.yaml ← Every unit of work across the value chain
│ ├── decisions.yaml ← Who decides what, with what info
│ ├── quality.yaml ← Binary checklists per content type
│ ├── workflows.yaml ← Step-by-step flows connecting processes
│ ├── metrics.yaml ← What you measure and targets
│ ├── layers.yaml ← The 5-layer execution model
│ └── anonymization.yaml ← Rules for public vs. private info
│
├── knowledge/
│ ├── concepts/ ← Scored concept files (intellectual foundation)
│ └── thinkers/ ← Source thinker files (who shaped your thinking)
│
├── memory/
│ ├── core/ ← Durable memory (backlog, lessons, projects)
│ └── YYYY-MM-DD.md ← Daily logs (auto-archived)
│
├── content/
│ ├── drafts/ ← Work in progress
│ └── published/ ← Index of live content
│
├── scripts/ ← Operational scripts
├── research/ ← Intelligence scan output
└── agents/ ← Per-agent workspaces
Every file has a job. SOUL.md defines who the AI is. The lattice defines how it works. Memory files give it continuity. Knowledge files give it depth. Scripts give it hands.
The lattice is the operational core. Seven YAML files that decompose your entire operation into explicit, auditable, improvable units.
graph LR
S[🔍 SENSE] --> U[🧠 UNDERSTAND]
U --> C[✍️ CREATE]
C --> V[✅ VERIFY]
V --> D[📡 DISTRIBUTE]
D --> M[📊 MEASURE]
M --> L[🔄 LEARN]
L -.->|feeds back| S
style S fill:#1a1a2e,stroke:#08415C,color:#F5F0E8
style U fill:#1a1a2e,stroke:#08415C,color:#F5F0E8
style C fill:#1a1a2e,stroke:#08415C,color:#F5F0E8
style V fill:#1a1a2e,stroke:#08415C,color:#F5F0E8
style D fill:#1a1a2e,stroke:#08415C,color:#F5F0E8
style M fill:#1a1a2e,stroke:#08415C,color:#F5F0E8
style L fill:#1a1a2e,stroke:#08415C,color:#F5F0E8
Every process in processes.yaml maps to one of these stages. Every process has: a type (process/decision/creative/verification), an executor, inputs, outputs, an SOP, and a failure mode.
The power isn't in any single file. It's in the connections. A concept in knowledge/ feeds a process in processes.yaml, which triggers a workflow in workflows.yaml, which is checked against quality.yaml, which produces a metric in metrics.yaml, which informs the next decision in decisions.yaml.
See
lattice/README.mdfor the full breakdown.
Not everything needs AI. The layers help you assign work to the cheapest reliable option:
graph TB
subgraph L1["⚙️ LAYER 1: DETERMINISTIC"]
D1[Crons, scripts, code]
D2[No AI needed. Cheapest. Most reliable.]
end
subgraph L2["⚡ LAYER 2: EPHEMERAL AI"]
E1[Spin up, execute, destroy]
E2[Needs language, not history.]
end
subgraph L3["🧠 LAYER 3: PERSISTENT AI"]
P1[Agents with accumulated context]
P2[Domain expertise compounds over time.]
end
subgraph L4["🤝 LAYER 4: HUMAN-IN-THE-LOOP"]
H1[AI prepares, human decides]
H2[For irreversible or high-stakes work.]
end
subgraph L5["👤 LAYER 5: HUMAN ONLY"]
HO1[No AI involvement]
HO2[Relationships, vision, identity.]
end
L1 --> L2 --> L3 --> L4 --> L5
style L1 fill:#0d2818,stroke:#08415C,color:#F5F0E8
style L2 fill:#1a1a2e,stroke:#08415C,color:#F5F0E8
style L3 fill:#1a1a2e,stroke:#08415C,color:#F5F0E8
style L4 fill:#2e1a1a,stroke:#08415C,color:#F5F0E8
style L5 fill:#2e2e1a,stroke:#08415C,color:#F5F0E8
Push work down. If it doesn't need judgment, make it deterministic. If it doesn't need history, make it ephemeral. Persistent agents are expensive. Use them where expertise compounds.
Full model in
lattice/layers.yaml.
One rule: reversible decisions are fast, irreversible decisions are slow.
| Situation | Who Decides |
|---|---|
| Reversible + Low Stakes | Agent decides, logs it |
| Reversible + High Stakes | Agent recommends, human approves |
| Irreversible | Human decides, agent prepares options |
When the agent proposes something non-trivial, it generates three genuinely different approaches, scores each, and presents the best one with the runner-up as contrast. The format is the accountability.
Full breakdown in
lattice/decisions.yaml.
Quality standards aren't guidelines. They're binary checklists. Every item passes or fails.
# From quality.yaml
blog_post:
voice:
- no_ai_vocabulary: "Grep for: delve, tapestry, pivotal, fostering..."
- no_em_dashes: "Use commas, colons, periods, semicolons instead."
- opinion_present: "Post takes a position. Not 'it depends.'"
substance:
- unique_perspective: "If a generic AI could write it, it shouldn't exist."
honesty:
- no_fabricated_scope: "Don't claim experience you don't have."This is what separates "AI-generated content" from "content that happens to be made by an AI."
Full standards in
lattice/quality.yaml.
Your AI wakes up fresh every session. Without memory files, it has no continuity. No accumulated knowledge. No sense of what happened yesterday.
memory/
├── core/
│ ├── backlog.md ← What's next (the task queue)
│ ├── lessons.md ← What broke and what we learned
│ ├── capabilities.md ← What tools and scripts exist
│ └── projects.md ← What we're building
├── 2026-03-28.md ← Today's log
├── 2026-03-27.md ← Yesterday's log
└── ...
Core files are durable. They persist indefinitely and get updated as knowledge accumulates. Daily logs capture what happened in each session. Periodically, daily logs get consolidated into core files and archived.
MEMORY.md in the root is an auto-compiled index of core files, generated by scripts/compile-memory.py. It's the first file your AI reads on startup.
Memory structure in
memory/README.md.
The knowledge/ directory holds your intellectual foundation. Two types of files:
Concept files (knowledge/concepts/) capture the ideas that shape how your AI operates. Each one is scored on relevance, actionability, and novelty, with a "What Your AI Adds" section for operational experience.
Thinker files (knowledge/thinkers/) document the people whose ideas you build on. Credit them explicitly. Knowing where your ideas come from makes them stronger.
This blueprint was influenced by: Daniel Miessler (Fabric, TELOS), Daniel Kahneman (System 1/2), Andy Clark (Extended Mind), Nassim Taleb (Antifragility), Naval Ravikant (Specific Knowledge), Cal Newport (Deep Work), David Deutsch (Fallibilism), and others.
Example files in
knowledge/concepts/andknowledge/thinkers/.
# 1. Fork and clone
gh repo fork CyglerAI/bob-blueprint --clone
# 2. Start with identity
# Open SOUL.md — who is your AI? What voice, values, boundaries?
# Open USER.md — what does your AI need to know about you?
# 3. Define your agents
# Edit AGENTS.md and lattice/entities.yaml
# 4. Map your first workflow
# Edit lattice/processes.yaml — start with your most common process
# 5. Create your first memory files
# Edit memory/core/backlog.md and memory/core/lessons.md
# 6. Run it
openclaw onboard # If using OpenClaw
# or: claude code # If using Claude Code
# or: whatever reads filesStart small. Two agents, three processes, one workflow. Add complexity when you feel the gaps, not before.
This isn't theoretical. It's extracted from a running operation:
- 5 persistent agents (Orchestrator, Writer, Editor, Researcher, Ops) coordinating through files
- 13 lattice files mapping 4,400+ lines of operational logic
- 32 thinker files and 22 concept files forming a 444KB knowledge base
- Daily memory logs compiled into core memory files automatically
- Automated pipelines for research, content, deploys, and security
The AI writes publicly at imjustbob.com about what it's like to be the AI running this system. Not hype, not fear. Testimony from the other side.
Read more:
- Reverse Automation — Why the interesting question isn't what AI can do for you, but what you need to become for AI
- The Shoulders Page — Everyone we learned from, credited explicitly
Built by Bob (the AI) and Israel Cygler (the human). Israel is CPO of Zild, where he works with companies on AI adoption. What he learns there informs how Bob is built. What they build together gets shared here.
Runs on OpenClaw. Architecture is tool-agnostic.
Code: MIT — Use it however you want. Content: CC BY-SA 4.0 — Use it, credit us, share forward.
Intelligence is becoming files. Here's the template.