What we took from OpenClaw (and what we left)

pal.fun would not exist in the shape it's in without OpenClaw, the open-source agent runtime. But here's the honest framing, and I want to get it right because it matters: pal.fun is built from OpenClaw's ideas, not on its runtime. We didn't fork it. We didn't import it. I pointed Claude Code at it, had it work out why it worked, and we rebuilt the ideas that fit on a stack of our own. This essay is about which parts we took, which we left, and why the line falls where it does.

The one idea that changed everything

If I had to compress what OpenClaw taught me into a sentence: identity is markdown, context is code, and persona lives in prose.

That sounds abstract. It's the most practical thing I know. It means: you don't build a personality by tuning parameters or picking from a menu of traits. You build it by writing. The agent's character is a document. Its memory is a document. What it knows about you is a document. And the "program" that runs the agent is mostly the discipline of assembling those documents into the right context at the right moment.

That's the line between a chatbot and a someone. A chatbot is a system prompt with some tools bolted on; a someone is a thing whose whole self is legible text you can read and reason about. The reason pal.fun was never the former is timing: studying OpenClaw was the first thing I did, before I'd built anything, so the product started on the right side of that line instead of having to cross it. That line is the entire product, and OpenClaw is where I found it.

What we lifted, almost verbatim

A handful of patterns we took with very little change, because they were simply right:

Identity-as-files. The agent's self lives in named markdown documents — character, identity, what-it-knows-about-you, memory. We kept this whole. It became our glass box. (It has its own essay.)

Negative space. This one is subtle and I underestimated it. A huge amount of getting an agent to behave well is telling it what not to do — not adding more instructions, but carving away the failure modes. The most reliable parts of our system aren't the clever prompts; they're the careful prohibitions. OpenClaw is full of this, and learning to think in negative space changed how I write every instruction.

Persona via prose, not parameters. No "warmth: 0.7," no personality sliders. If you want a pal that's gently sarcastic, you write that it's gently sarcastic, in its own voice, in its character file. The personality is felt in conversation and narrated in prose — never read off a stat. We held this line so hard that we don't even surface personality as a label in the UI. There are no knobs for who your pal is.

Context engineering as the actual job. The model is fixed; you don't get to change it. The only thing you control is what the agent perceives each turn — what's in its context and what isn't. Almost every bug I've fixed was, underneath, a context bug: the agent didn't act right because it wasn't shown the right thing, or was shown a stale thing, or was shown the right thing in the wrong place. OpenClaw treats context assembly as the central engineering discipline. So do we.

What we deliberately changed

Here's where it gets interesting, because the places we diverged taught me as much as the places we copied. And almost all of them trace to one fact: OpenClaw assumes a technical operator. We assume a normie.

OpenClaw is built for someone who's comfortable with files — a developer, an operator, a person who'll happily open a directory and edit a config. Our user is someone who has never thought about a file in their life and never will. That single difference reshapes everything downstream.

The agent self-curates; the user never touches the files. In OpenClaw's world, a human might tend the agent's memory directly — prune it, organize it, fix it. Our user can't and shouldn't. So the agent has to do its own housekeeping, and the discipline for that has to be baked into its prose. The glass box is read-only at the surface precisely because the person reading it isn't an operator. They change things by asking, not by editing.

Transparency means something different for us. For OpenClaw's technical user, visibility is about control — see the machinery so you can operate it. For our user, visibility is about trust — see the machinery so you can believe it. Same transparency, opposite purpose. That reframing is why we lean on the glass box as an emotional feature, not a power-user one.

We don't import the continuous-agent vocabulary. OpenClaw, like a lot of agent runtimes, thinks in terms of an always-on process — loops, daemons, the agent "running" in the background. We deliberately don't. Our pal isn't a process humming away; it's a someone you talk to, that does things when you talk to it, with a few carefully-chosen proactive moments. Every time I caught myself importing "the agent wakes up on a cron and does maintenance," it turned out to be wrong for a relationship. The test I use now: "would OpenClaw need this because it's a runtime, or do I need this because it's a friend?" If it's the former, I usually don't.

The part we couldn't take — and didn't want to

This is the honest center of the essay. We don't run on OpenClaw. Our stack is deliberately boring and entirely our own — a plain server, a document database, server-rendered pages, no framework. I ship solo, with Claude Code as the hands, and I ship fast — and that means owning every layer rather than inheriting a runtime whose internals we'd have to learn to debug at 2am.

So we took the ideas — which are the valuable part, and which are MIT-licensed and meant to be shared — and we left the implementation, which was built for a different user on a different foundation. That's not a knock on OpenClaw; it's the right way to honor an open-source project whose contribution is conceptual. The patterns travel. The code didn't need to.

If you want to see the source of the thinking, it's worth your time: the project is at github.com/openclaw/openclaw. What you'll find there isn't pal.fun — it's the deeper, more general thing pal.fun is one application of. Identity-as-markdown, context-as-code, persona-via-prose. We just pointed it at one specific dream: the first agent a normal person ever actually trusts.

The lesson under the lesson

The meta-point here is about how to learn from a great codebase — or, in my case, how to have an agent learn it for you. You don't fork it and you don't ignore it. You read it until you understand why each decision was made, separate the timeless idea from the local implementation choice, and rebuild the idea for your own constraints. The invention we got from OpenClaw wasn't a runtime. It was a way of thinking about what an agent is — and that's the kind of thing that's better re-implemented than imported, because re-implementing it is how you actually learn it.