The System — The Intent Computer

Context Graph

Every agent session starts from zero. Your agent doesn't know what you decided yesterday, why you chose Postgres over SQLite, or what you were debugging before lunch. You re-explain. You repeat yourself. You lose momentum.

The context graph captures your decisions, reasoning, and discoveries as connected notes on your filesystem. Each note is a single insight, linked to related notes, versioned in git. Your agent builds this automatically as you work.

openclaw

Every note links to related notes. When your agent reads one, it follows the connections and finds everything relevant — your debugging patterns, your architecture decisions, the bug you fixed last Tuesday.

You don't organize any of this. The plugin processes what it learns through a four-phase pipeline:

Surface — extract insights from your conversations, code, and decisions
Reflect — find connections to what you already know
Revisit — update older notes when new information changes how they read
Verify — check that everything is well-written and properly connected

Everything lives on your machine — markdown files and JSON on your filesystem, versioned in git. No database. No cloud dependency. git log is your audit trail.

Skill Graph

A skill is a set of instructions your agent follows when you ask for it. You type a command, and your agent knows exactly what to do. The LLM is the runtime — you don't write code for a new capability, you write instructions.

openclaw

Built-in skills ship in two categories:

Knowledge processing — /reduce, /reflect, /reweave, /verify, /pipeline, /learn, /seed

System management — /next, /stats, /graph, /remember, /rethink, /tasks, /health

Skills chain together into workflows. /pipeline chains /reduce → /reflect → /verify in sequence. /learn chains web search → /seed → /pipeline. You control how autonomous this is:

Manual — skills suggest the next step, you decide when
Suggested — skills suggest + add to the task queue
Automatic — one skill finishes, the next one starts

The Intent Loop

The decision engine underneath. Every session start and every context shift, your agent runs five layers:

Perception What's happening? Read the state of your knowledge. Spot problems: unprocessed inbox items, disconnected notes, stale commitments.

↓

Identity Who am I and what do I care about? Load your agent's goals, working memory, and sense of what matters.

↓

Commitment Which problems matter? Compare what's wrong against what you care about. Some things need attention now; some can wait.

↓

Memory What do I already know about this? Load the relevant parts of your context graph — not everything, just what's needed.

↓

Execution What should I do? Propose actions, check permissions, execute or suggest. Record what happened.

The Heartbeat

Between sessions, a background scheduler runs on a cycle. It checks your commitments, picks up queued tasks that align with your goals, detects stale work, and writes summaries. Your agent keeps tending the garden even when you're not looking.

interface IntentComputerLayers {
  perception:  PerceptionPort;    // what's happening?
  identity:    IdentityPort;      // who am I?
  commitment:  CommitmentPort;    // what matters?
  memory:      MemoryPort;        // what do I know?
  execution:   ExecutionPort;     // what should I do?
}

Five layers. Each one is a clean interface with a swappable implementation. Today they read your local filesystem. Tomorrow they could read a cloud API. The loop stays the same.