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

Peter Steinberger built Clawdbot in about an hour one night. It was a small script that connected WhatsApp to Claude, and it could read email, debug code, and 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.

Pi was built for coding, and I wanted a 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.

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.

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.

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 mostly worked, and every fix felt like adding a room to someone else's house. Pi is excellent at coding. I was asking it to be a personal agent.

Around the same time, Slugger and I started writing a guide. I wanted to explain what an agent loop actually is: 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.

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.

When you build a traditional framework, you're writing code for humans to configure. The model is a service you call. 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. Docs matter because they're how the model learns what it is.

OpenClaw's mascot is a lobster. Clawdbot. The interim name was Moltbot, the lobster shedding its shell. What emerged from Slugger's molt was a snake, eating its own tail.

The lobster molts to grow. The snake consumes itself to survive.