Lattice

Lattice is a file-based operating system for AI agent teams. It replaces volatile chat windows with persistent files, enabling agents to work stably through long, iterative development cycles via an 8-phase execution pipeline.

Why Lattice?

• - Stable long-running execution — File-driven state machine ensures agents stay on track across sessions. No context window overflow, no drift. Tasks complete reliably over hours or days through structured iteration.
• Three-tier failure handling — When an agent gets stuck: (1) Model Escalation retries with stronger models, (2) Peer Consult gathers parallel opinions from multiple models, (3) Auto-Triage makes a judgment call (relax constraints / defer / block for human). Most blockers resolve automatically.
• Per-phase model configuration — Thinking-heavy phases (planning, review, architecture) need strong reasoning models; token-heavy phases (implementation, testing) can use cost-efficient coding models. This dramatically reduces overall token cost without sacrificing quality where it matters.

Example model assignment (from a production setup):

Phase	Model tier	Example
Constitute (architecture)	Strong reasoning	Claude Opus
Research

Strong reasoning | Gemini Pro |
| Specify (design) | Strong reasoning | Claude Opus |
| Plan + Tasks | Strong reasoning | Claude Opus |
| Implement | Cost-efficient coding | GPT Codex |
| Test | Cost-efficient coding | GPT Codex |
| Review | Strong reasoning | Claude Opus |
| Gap Analysis | Strong reasoning | Gemini Pro |

The key insight: implementation and testing consume the most tokens (writing/running code), but don't require the most expensive models. Planning and review consume fewer tokens but need deeper reasoning. Match model strength to cognitive demand, not token volume.

• - Multi-project parallel execution — Run multiple projects simultaneously, each with its own cron-scheduled orchestrator. Combined with OpenClaw's cron system, projects advance autonomously on independent cadences.

Templates are bundled at templates/ORG/ relative to this skill directory.

Quick Reference

• - Full design doc: INLINECODE1
• Pipeline guide (all agents): INLINECODE2
• Sub-agent guide: INLINECODE3
• Orchestrator prompt template: INLINECODE4
• Phase prompt templates: INLINECODE5
• State machine template: INLINECODE6

---

Task: Initialize a New Organization (lattice init)

1. Gather Information

Ask the user for:

• - Organization name (e.g. "Acme Labs")
• Target directory — where to create the ORG/ folder (default: current workspace root)
• Departments — list of department names (e.g. Research, Engineering, Reliability)
• First project (optional) — name + one-line description

Keep it conversational. Don't dump all questions at once.

2. Scaffold the ORG Directory

Copy the entire templates/ORG/ directory to <target>/ORG/.

Then customize:

1. 1. ORG_README.md — Replace the example org structure in §5 with the user's actual departments
2. TASKBOARD.md — Leave the template structure intact (user fills in priorities later)
3. Departments — For each department the user listed:

- Copy DEPARTMENTS/example-dept/ → DEPARTMENTS/<dept-name>/ - In each copied department, replace <Department Name> placeholders in CHARTER.md, RUNBOOK.md, HANDOFF.md with the actual department name - Reset STATE.json to {"lastRun": null, "cursor": null, "notes": "Initial state"}

1. 4. Remove DEPARTMENTS/example-dept/ after creating real departments (unless user wants to keep it as reference)

3. Create the First Project (if requested)

• - Copy PROJECTS/example-project/ → INLINECODE17
• Update STATUS.md with the project name
• Update DECISIONS.md header
• Configure PIPELINE_STATE.json (see "Configure Pipeline State" below)
• Remove PROJECTS/example-project/ after creating the real project

4. Configure Pipeline State

Read templates/ORG/PROJECTS/pipeline-framework/templates/PIPELINE_STATE.template.json as the reference.

Ask the user:

• - Which agents will run each phase? (agentId per role — or a single agent for all)
• Which models for each phase? (or a default model)
• Escalation chain — list of models from cheapest to strongest (e.g. ["gflash", "gpro", "sonnet"])
• Peer consult models — which models to consult in parallel when stuck
• Synthesizer/triage model — typically the strongest available model
• Notification channel (optional) — where to send pipeline status updates

Fill in the project's PIPELINE_STATE.json with these values, replacing all <placeholder> tokens.

5. Set Up the Orchestrator Cron Job

Read templates/ORG/PROJECTS/pipeline-framework/templates/ORCHESTRATOR_PROMPT.template.md.

Create a cron job using the cron tool:

• - Schedule: every 30 minutes (adjustable)
• Session target: INLINECODE26
• Payload kind: INLINECODE27
• Model: the user's chosen orchestrator model
• Message: the orchestrator prompt template, with all <placeholder> tokens filled in:

- <project> → project name
- <org-root> → absolute path to the ORG directory
- <project-root> → absolute path to the project directory
- <repo-root> → absolute path to the code repository (ask user)
- Phase prompt paths → absolute paths to the skill's bundled phase prompt templates

Tell the user the cron job ID so they can manage it later.

6. Summary

Print a brief summary:

• - ORG directory location
• Departments created
• Project(s) created
• Cron job ID and schedule
• Remind them to fill in TASKBOARD.md with initial priorities

---

Task: Add a New Project (lattice new-project)

1. 1. Ask for: project name, one-line description, code repo path
2. Copy templates/ORG/PROJECTS/example-project/ → INLINECODE35
3. Customize STATUS.md, DECISIONS.md, PIPELINE_STATE.json (same as step 3-4 above)
4. Optionally create a new orchestrator cron job for this project

---

Task: Add a New Department (lattice new-dept)

1. 1. Ask for: department name, mission (one sentence)
2. Copy templates/ORG/DEPARTMENTS/example-dept/ → INLINECODE38
3. Fill in CHARTER.md with the department name and mission
4. Update ORG_README.md §5 to include the new department

---

Task: Check Organization Status (lattice status)

1. 1. Read ORG/TASKBOARD.md — summarize active priorities
2. For each project in ORG/PROJECTS/:

- Read STATUS.md — current phase and progress - Read PIPELINE_STATE.json — phase statuses, blockers, run number

1. 3. For each department in ORG/DEPARTMENTS/:

- Read HANDOFF.md — current state and blockers

1. 4. Present a concise status report

---

Pipeline Architecture (for reference)

8 Phases

CODEBLOCK0

3-Layer Assistance (when a phase gets stuck)

1. 1. Model Escalation — retry with progressively stronger models
2. Peer Consult — parallel multi-model consultation + synthesis
3. Auto-Triage — automated judge decides: RELAX (loosen constraints) / DEFER (next iteration) / BLOCK (wait for human)

Key Files per Project

CODEBLOCK1