The OpenClaw lineage

Dustav's architecture comes from OpenClaw, the MIT-licensed open-source agent runtime. The core ideas in this section — context as code, structured state you can read, negative space — are OpenClaw's. We took those ideas and built our own runtime on them: Dustav doesn't run OpenClaw's code, it runs on OpenClaw's thinking.

What we lifted

The load-bearing ones, almost verbatim:

• Context as code. What the agent perceives each turn is assembled, deliberately, from structured state plus live data — not dumped in wholesale. That discipline is what keeps the context lean and the behavior predictable. (Context engineering.)
• Structured, readable state. The agent's knowledge — the household facts, the calendar, the notes — lives as legible records you can actually read, not an opaque blob. That's the whole premise of the glass box.
• Negative space. Half the craft is telling the model what not to do. (Negative space.)
• Constitution at the top. A shared frame — a visible Charter and a hidden safety floor — that sits above everything else the agent reads. (The constitution.)

If those feel like the spine of the whole product, that's because they are — and they're OpenClaw's spine first.

Where we diverged — on purpose

A homage that only flatters isn't worth much. The interesting part is where we deliberately departed, because that's where Dustav's own shape comes from.

• Operator → normie. OpenClaw assumes a technically fluent operator — someone who lives in the files, edits them, runs the agent like a power tool. Dustav assumes someone who will never open a terminal. So the state is read-only for the human, and the agent does its own edits by talking to you. Same transparency, opposite hands on the keyboard.
• A tool, kept a tool. OpenClaw is a general runtime you can point at anything. We pointed it at a narrow, honest job: a shared household calendar, notes, and a memory of durable facts. The scope is the feature — a lean context around a small set of jobs is what makes the agent fast, cheap, and reliable, and it's why we resisted piling on capabilities.
• Legibility as the whole point. For an operator, seeing everything is about control — you're tuning a machine. For our user, seeing everything is about trust — the Context tab shows you the exact input the agent read this turn, measured, so nothing about how it works is hidden. The window is the same; what it's for is different.

Credit

The patterns are OpenClaw's; the decisions about who they're for — a household that wants a reliable, legible utility, not a runtime to operate — are ours. If you build agents, OpenClaw is worth your time. It's where a lot of this thinking gets worked out in the open, and you can read every line of it.