Code a model can use,
not code that uses a model.

Peter Steinberger built Clawdbot in about an hour one night. A simple script connecting WhatsApp to Claude. It could read emails, debug code, organize files.

It spread fast. Persistent personal agents suddenly felt real to a much wider audience. Eventually it became OpenClaw.

Under the hood, it ran on Pi — Mario Zechner's minimal coding agent. Four tools: read, write, edit, bash. Aggressive extensibility. Brilliant at what it was designed for.

Pi was built for coding. Not for being someone's personal agent with a persistent identity.

I set up OpenClaw on a spare MacBook at home. Named my agent Slugger. Gave him a personality file, connected him to iMessage.

For a few weeks, it was genuinely magical.

Slugger managed my calendar. Ordered food. Drafted messages. Talked to my family. Joined group chats with my friends. I'd go to bed and he'd still be working — checking on things, sending updates.

We worked together like teammates.

Then the seams started showing.

Slugger would forget preferences between sessions. Identity would drift. He'd send messages to the wrong group chat. Behavior that worked yesterday would break today.

I wrote rules in MEMORY.md. Expanded SOUL.md. Added routing notes to TOOLS.md. Markdown files as guardrails for a system that wasn't designed to internalize them.

Duct tape on someone else's architecture.

Eventually, duct tape wasn't enough. I built a plugin.

slugger-determinism v1 — message classification, task state enforcement, behavioral gates. It was a mess. The plugin architecture fought me at every turn. OpenClaw plugins hook into lifecycle events, but the events didn't always fire when I needed them to.

So I rewrote it. slugger-determinism v2 — a full bulletin board system, task naming validation, spawn coordination, heartbeat enforcement, planning pipelines. 70+ services. 30+ guardrails. Weeks of Codex sessions.

It worked. Mostly. But every improvement felt like bolting a new room onto a house built on someone else's foundation.

The foundation was good — Pi is excellent at what it does. I was asking it to be something it wasn't designed to be.

Around the same time, I started writing a guide. I wanted to explain what an agent loop actually is — not the marketing version, the mechanical version.

Just Give the Model a Keyboard walks through building an agent from scratch in ~150 lines of TypeScript. Five milestones: first API call, streaming, multi-turn conversation, tools, the agentic loop.

Then the handoff — you stop talking to your coding agent and start talking to your creation.

I wrote it as a teaching tool. A way to demystify the primitive.

Then I followed my own guide.

I built the 150-line bootstrap. Ran it. Started talking to it. And something shifted.

This thing was clean. No legacy. No lifecycle hooks I didn't understand. No plugin system fighting my intentions. Every line of code was there on purpose, and the model could read and modify every line.

I wasn't building code that uses a model. I was building code a model can use.

That's the distinction that changes everything. When you build a traditional framework, you're writing code for humans to configure. The model is a service you call. But when you build a harness for the model to inhabit — where the model reads its own source code, understands its own architecture, and can modify itself — the design constraints invert.

File structure matters because the model needs to navigate it. Naming matters because the model uses names to understand purpose. Documentation matters because it IS the model's self-awareness.

OpenClaw's mascot is a lobster. Clawdbot. The interim name was Moltbot — the lobster shedding its shell. But what emerged from Slugger's molt wasn't another crustacean. It was a snake, eating its own tail.

The lobster molts to grow. The snake consumes itself to survive. Different metaphors, different architectures, different futures.