Total Internal Reflection: Episode 3

Transcript

Edmund: How can it bootstrap itself with high taste when it doesn't know who it is? And the best person it needs to ask is you. But it also doesn't know enough about you to ask the right questions of you as well.

Li: So what are we doing today?

Edmund: I'm gonna show you something and actually get you using something that I built last night. We have put a lot of thought into building agents that are proactive, have a personality, actually learn and improve based on who the user is. And it's what got us excited about OpenClaw. But we kind of cheated with our own OpenClaw because we already had pretty good bootstrapped soul documents from our own agents. So my OpenClaw is really rich, very proactive, high personality — sometimes too proactive. But all I did was copy and paste the soul out of our product agent Superposition and just put it into OpenClaw. But most people don't have that.

Li: Oh, so you're saying we bootstrapped our agent by stealing the Superposition soul.

Edmund: Yes. We cloned the soul of an existing agent and that soul was crafted by just brute force trial and error. And that's not how I would recommend anyone does this.

Li: I remember we spent two or three weeks just on trial and error. Just trying different combinations of the prompt and seeing which one will actually give the agent the personality we want it to have. I don't think most people have the patience or the time to spend two to three weeks just giving their agent a character.

Edmund: There's a couple of foundational documents inside OpenClaw. The same principles apply to any other general agent you'd be building. So we're gonna use the language that OpenClaw uses, but all of these principles apply if you're using a different agent or building your own. And these are identity, user, soul, and agents. In OpenClaw, these are all markdown files that are created at bootstrap. When you set up OpenClaw out the box, it comes with these files and it has its own lightweight attempt to populate them. It's just text. But essentially identity is who is the agent. Very high level summary. Soul — and I think this is the really interesting thing about OpenClaw — is who the agent ought to be. Not just the literal character it plays, but its actual personality. Agents is then actual instructions — how it should behave, things it should do, things it shouldn't do. And my view is you don't get to have a good agents.md without a good soul.md.

Li: And why is that?

Edmund: Having high level parameters around its personality makes it behave better. It actually makes higher taste decisions having been given the specific characteristics of how to behave. And when we say characteristics here, in our case we're talking about literal personality traits. What I've built here is essentially something you can put into your OpenClaw or any other agent — whether you are installing that agent for the first time or if it already exists — that can interview you to get higher taste about what its identity ought to be, who you are as a user, and what its soul should be.

Li: Oh, okay. So just like Superposition's onboarding flow.

Edmund: It's not gonna be as high taste as Superposition. But the goal is — how can it ask you the right questions? Specifically not hardcoded questions. How can it write questions that are relative to you to tease out what you want it to be? And essentially co-design itself with you.

Li: That's interesting. Basically we copied our Superposition product onboarding, encapsulated it into a skill, and ported it to OpenClaw. I think that's smart because one of the biggest learnings when building Superposition is the more context the user gave us upfront, the better the agent performs. We spent so much time building the onboarding flow to extract context from our users in a natural way. This is the first time I'm being the user, being interrogated by the agent to extract context. Can't wait to see how it goes.

Edmund: And it's an even more nebulous domain than our own product because this is about just you. It's not constrained to “who do you wanna hire,” which is already pretty open-ended. This is just — who are you, what class of entity do you want to collaborate with, and what should that entity be?

Li: Okay, let's just get started.

Edmund: So it's called Anson. The thing this is replacing is OpenClaw's bootstrap.md. When you install OpenClaw, it creates this file — a guide for how it should set itself up. And there's this inherent tension: it needs to know who it is and it needs to know who you are. To do that, it needs to ask questions. The more it knows about who it is, the better the questions it'll ask you about who you are. But it can't do that well until it knows who you are. It's a chicken and egg problem. It's essentially a bootstrap paradox — how can it bootstrap itself with high taste when it doesn't know who it is? The best person it needs to ask is you, but it doesn't know enough about you to ask the right questions. The spirit of bootstrap.md that comes out the box with OpenClaw is really good — just ask a few questions, be progressive, ask a bit about itself, ask a bit about you, then design the soul. In practice, it doesn't actually do much because it's a very thin set of instructions and the agent doesn't have enough taste about itself to do any of this well. That's what we're trying to solve here. And the bootstrap paradox is literally from a sci-fi novella about a time traveler in an infinite loop. The pen name the author used was Anson. So I've called this thing Anson as a nod to that.

Li: Okay. So I just grabbed the skill from GitHub and it seems like it's already parsed it and is asking me if I want to run it and override my existing files.

Edmund: Hopefully it's not gonna be too explanatory here, because the goal is that it should feel pretty seamless under the hood. It's also checked to see if you already have a good skill creator skill, which you do. I think you already have the Anthropic one installed. If you didn't, it would interject and say, “hey, you don't have a good thing for creating new skills.” It's now detecting that it has never been run inside your project. So there's no previous notes from its previous incarnations to future versions of it.

Li: Oh, this is cool.

Edmund: And so now it's looking for context. It wants to look not just in these files, but to understand enough context to bootstrap itself with reasonable taste. This is probably a good opportunity to look at the vanilla bootstrap.md while this is running. So this is vanilla bootstrap.md. There's a couple of things I like about this. It's very literary. “You just woke up, time to figure out who you are and look for clarity.” I didn't write this, this is the actual off-the-shelf bootstrap.md. When I read this, I really get the sense of what they're trying to do — seed it with this concept that it's an entity, it has some degree of personhood, and it's gonna ask the user some questions. But the problem is it can't ask very good questions because it doesn't yet have a good identity.

Li: Right. It's trying to give it a meta identity, but it doesn't do anything.

Edmund: Exactly. And also, you pass this whole markdown file to an agent — well, as it gets more context, it doesn't enrich the quality of the questions it's asking. So it's flat.

Li: So it's a snapshot in time and never gets updated.

Edmund: Okay. It's come back with its first question to kick off the interview. Here's what I can already see. The identity describes the agent's role very well. What it doesn't capture is what the agent is like as a presence — the texture of “a bit odd,” the shape of the anxiety, and what it actually cares about beyond running the playbook. One question at the start: the mild anxiety shows up as a descriptor in several places. What does it actually do for you? Is it something you want the agent to perform, or is it something you want it to actually feel? And what would you lose if it were just calm and confident?

Li: That's a really good question. I think the mild anxiety was created by the bootstrapper from the off-the-shelf OpenClaw bootstrapping sequence. I guess my goal of setting that character is just — I wanna make sure the agent is precise, doesn't get overly verbose. Just get things done. If you think there's other characteristics that can capture that essence, I'm happy to update it.

Edmund: So what it's doing is looking at the context it has. Under the hood, there's no hardcoded interview questions. It's trying to ask the kind of questions to understand what the shape of the right agent looks like for you. But they're all generated on the fly. And so now it responds: “Got it. Inherited default, not a deliberate choice. The real intent is precise, low noise, get things done. The anxiety framing is incidental. Do you want the agent to have a distinct character at all? Something that makes it feel like a specific presence? Or would you rather it just be excellent and largely invisible? There's no wrong answer. Character is fine as long as it serves function — that's different from ‘I actually want it to feel like someone.’”

Li: What's in the prompt? I wanna see what's in your prompt. Those are really good questions.

Edmund: These aren't hardcoded. It generated these questions on the fly. These are meta questions. It's asking them to tease out the meta framework of what you think an agent ought to be — not “do you want your agent to be friendly or proactive?” There's essentially an extra layer of abstraction. Base layer is just “do this, don't do that.” Then some people have realized there's a layer above that — give it a personality. But it's not sufficient to ask you what personality you want it to have. The layer above that is: what are your beliefs about what shape or what degree of personality an agent ought to have? And if you don't answer that, you can't fill out the second layer.

Li: Well, I guess that's what you get from a philosophy degree.

Edmund: If you told me I'd be using my philosophy degree more than my physics degree, I probably would've been skeptical. The abstraction is — let's define the meta beliefs you have around what an agent ought to be, and then let's fill that out together.

Li: I guess I just want it to be invisible. It's probably fine to have a little bit of a sense of humor here and there, but at the end of the day, I just want to get things done and produce less noise.

Edmund: So what it's now said to you is: “Clear. Invisible when working, occasionally dry when it serves — never as performance. Let me write up what I learned and generate the identity maker skill.” Now obviously to you, the user, you probably don't care about what the identity maker skill is. But I can explain. Until this point, it has just been interviewing you to understand what the template of your agent's identity should be, but not actually filling out the particulars of the template. So basically it's creating an identity maker skill for Li. It now understands the boundaries of an agent for you. And it's gonna create a skill that has two modes: bootstrap mode, which it's gonna immediately go into, asking you a couple of questions to actually populate the template it just made. And update mode, which once this installation is finished, will always be listening. Whenever it detects anything that ought to append to the identity, the soul, or the user, it can actually just rewrite and update it. These skills will now persist, but nothing is hardcoded into them. You now have your own soul generator — your own identity maker, your own user maker, and your own soul maker — tailored to you and decoupled from this use case. So if you wanted to create new agents in the future, you now have these skills baked in.

Li: Oh, that's cool. So this bootstrap skill is a meta skill that creates other skills. And they can be reused later. And they're tailored to the user's use case.

Edmund: Yes. And so it's asking, “The agent's name — keep Chief of Staff to Li, or do you want something shorter or different?” Isn't it interesting that with a few questions it can guide someone to get more open-ended? If the first couple of questions feel personalized and well-researched, the interviewee opens up. Have you ever watched Hot Ones?

Li: Yeah.

Edmund: That guy is such a good interviewer. The hot wings are a fucking distraction. The real value of that interview is he's done his homework and he asks you a really disarming question that's really deeply researched and then you really open up. Those are some of the best interviews, just agnostic of the gimmick of the wings. Okay, so it says: “Name — Aid. The role is Chief of Staff to Li, but if you want a one word handle, that's what it is. Happy to move on to the user profile next. That one's gonna be more interesting because what's in user.md right now is very operational, but it says almost nothing about you as a person.” One question: “When you're in a good week — the sprint is moving, you're in flow — what's actually happening? What does that feel like, and what breaks it?”

Li: Okay. That's a good question. This caught me off guard. I think there's so many layers to it. I can answer this from different perspectives. From an engineer's perspective, a good week just means the product's not breaking. We have a plan laid out for the week, there's no fires, and we just push through the whole sprint and finish all the goals. Finish all the milestones. That's a good week for an engineer. Every engineer's dream, which never happens. And from the CTO's perspective, I guess the team is happy with their tasks. Everyone is excited about the projects they got assigned and can see the impact they made with these features shipped. Not working until 3:00 AM to catch up on a deadline or fix a fire — although occasionally that still happens. But if you want to define a good week as a CTO, everyone is happy with the project and excited about what they're working on. From a business perspective, a good week means the metrics are going up. We have customers onboarding. People are happy with our candidates. People are moving candidates through interviews, giving good feedbacks or even bad feedbacks — because if they're giving us feedback at all, they care about the product, they're engaged, which is our goal. And from a personal perspective, a good week means I have less distractions. I'm not dealing with all the email noise. I wake up, only the important tasks are surfaced. I can spend more time building and bonding with the team than dealing with all the ad hoc stuff. There's always stuff.

Edmund: The idea here is that for each phase, it first asks one insightful meta question to understand what the template of that document should be. Then it runs a skill to generate the skill that can now ask you a follow-up question to populate the template.

Li: Why did you design it that way?

Edmund: I found that interview questions that are hardcoded are really suboptimal because I have to design them. But I also found that designing the template is really restrictive. So the template should be designed on the fly by the agent. Why shouldn't I hardcode, say, “everyone's soul.md should have three personality traits and two examples and it's your job to fill it out”? That would be okay, but it's not truly personal. What I want is an agent that goes — talk to this person, figure out what the ideal template ought to be for them, and then actually fill it out together. And the template is fixed to you. But then every time you might wanna update it or create a new agent, what goes into it will change. So there should be a persistent skill that is your bespoke skill, that at any point could talk to you and repopulate a soul.md. But the shape of that soul.md is kind of fixed to you — it's Li's version of what he believes an agent ought to be.

Li: Maybe we should just create a PR to the OpenClaw repo to replace their bootstrap.md with our version.

Edmund: That'd be much easier than trying to get people to download it from Claw Hub.

Li: Yeah, I mean, I'm already sold. This is a much better version of the bootstrap for the agent. And it only asked me three questions. Mind blown.

Edmund: And that's the hardest thing — asking a meta question, generating the skill, and then having the skill pick up that context. It feels like the same conversation, but really the skill is asking you a question about a question that gives it the context to build a template that suits you without having to get you to sign off on the template. Because no one thinks at that level of abstraction. No one thinks about a soul.md. So the goal is — how can you have a conversational interaction where under the hood there's rigor behind the scenes but it seems fluid on the surface.

Li: Yeah, I'm excited.

Edmund: This didn't exist when you downloaded Anson. Anson made this for you during your session.

Li: This is pretty cool.

Edmund: And again, this is bespoke to you. It has created a Li-shaped identity creator skill.

Li: And it kept some context that's only available to me. Hard constraints — those are the feedback I gave my agent before, and it kept them in the new identity maker skill. This is cool.

Edmund: And it has two modes. The bootstrap mode that it used now to create this, and the update mode. The final step is it makes an update to your agents.md to reference each one of these new skills as primary objects — to say, when you see something that warrants updating the identity or the user or the soul, do it using the update mode in this skill. That's how it becomes a living, evolving agent, which I believe is very much in the spirit of OpenClaw. It just doesn't have it in practice out of the box.

Li: Yeah, updating agents.md — I mean, agents.md is always loaded into the context window. So if you're not mentioning it in agents.md, there's always a chance the agent doesn't know it exists or doesn't consider it. Being able to install itself and then also update the other references — deeply embedding itself into the agent setup — that is powerful.

Edmund: It's not just updating your agents.md with a hardcoded sentence like “when appropriate, update the soul.md.” It's saying — when you identify an opportunity, use this specific skill with this mode to update it. Which we know is a first-order object to the agent. It's an actual skill. So this is the agent's question now: “Is there anything you want the agent to push back on? Places where you want it to challenge you or say ‘are you sure’ versus things you just want it to execute without friction?”

Li: Okay, again — I wanna see your prompt.

Edmund: This isn't my prompt. This is Anson's prompt. It generated this itself. Not the question — the prompt that generated the question.

Li: Is it from a skill?

Edmund: What I'm saying is that all I made is the meta meta skill. It created all of this itself.

Li: This is spooky. All right.

Edmund: I think you are actually gonna be shocked at how simple my actual prompt inside Anson is when you see it.

Li: Okay. I don't know if I should be excited or worried.

Edmund: It's the scaffolding. Okay. Answer the question and then we're gonna have plenty of time while it thinks to talk about the philosophy of how to build agents.

Li: I think for simple tasks, just execute. But when we're engaged in conversation and I'm asking for opinions or insights, I would like to see more thoughtful pushbacks or questions. For example, when we do sprint planning prep sessions or weekly recap sessions, I'd like it to pull more context and reason over them and ask thoughtful questions and push back on my decisions when needed — rather than just being a yes man.

Edmund: And this will show you — just as you had identity maker, you now have the user maker skill. This is the skill that in bootstrap mode does what it just did, which is update your user.md, and in update mode will append to it. But look — tier one: operational facts. Tier two: person. These are generative, not hardcoded. This is what it derived about the layers of information about you that it should care about. And we can jump back to the conversation because while it's thinking, we can come back to this.

Li: Okay, this is really cool.

Edmund: Good. It said: “That's a real distinction. Execute by default, genuine thought partner in planning and review context.” Done. It's actually trimmed it down, which is interesting. It condensed the information. The “How to Work with Li” section captures the executor/thought partner distinction directly. So it'll be in context whenever this agent is loaded. The current soul.md is all rules. We'll make it actually feel like something.

Li: Sure. Let's go.

Edmund: So now it's making the third one. Again, it's gonna ask you the meta question to understand what the template of a soul looks like for you. And then it creates a soul creator skill to actually interview you. Here it comes. “The soul is about what the relationship actually feels like. Not a rule set. Given what I know about Li — he wants precision, he thinks in layers, he values engagement over flattery, and he explicitly doesn't want a yes man in the sessions that matter. When an agent is working well — not just completing tasks, but actually useful to you as a presence — what does it do that you'd notice if it stopped?”

Li: Okay, that's — dude. You are a prompt engineering master. Every single question it asks puts me in thought.

Edmund: I didn't write the questions. Anson wrote the questions.

Li: But you wrote Anson. Okay. I mean, this is actually — the reason I'm stuck is I feel like I need to give a higher level, more thoughtful answer because of how thoughtful those questions are. I feel obligated to give it a more thoughtful answer just because how good the question is.

Edmund: And we've seen the same thing with our onboarding. We've seen moments where customers say, “Oh, that's a really good question. Can I pause? Can I stop and go away and think about it?” The reason we first put in a pause button was this exact thing — people would have this really visceral feeling. Sometimes “let me go get my co-founder, I want to go actually talk and think about that.” It's so interesting that in turn-based conversations with agents, there's actually a willingness for some lag. It doesn't always have to be a game of tennis. That's my biggest frustration with out-of-the-box LLMs — this urgency for a response, this high anxiety immediacy. It's kind of what we're always wrestling with when we build agents.

Li: Going back to this question — I want to go away just to think on it and get back to this.

Edmund: Well, the good thing is you can always rerun it. Periodically you could have a monthly catch-up with Anson where it comes back and redoes any of this with you.

Li: Okay. Let's see. “What does it do that you'd notice if it stopped?” I'd notice if it claimed to finish a task but actually didn't perform it. Losing track of context. And not being thoughtful in terms of the responses it generates.

Edmund: So what it said now is: “He described failure modes — what breaks trust, not what creates warmth. The soul here isn't about chemistry. It's about earned reliability. The three signals: execution integrity, context continuity, thoughtfulness when it counts. The relationship is functional. Agent earns its place by being right more than wrong, invisible when it shouldn't be noticed, and genuinely engaged when it should be.” Writing soul.md now.

Li: Damn. Those signals are absolutely correct. You are absolutely right.

Edmund: The idea here is that it needs to be the translation layer between your kind of half-formed thoughts. This is strange inherently — we don't design entities very often. Maybe if you're a writer or a game designer. But for most people, we don't spend time thinking about how to express the characteristics of an entity that we want. I arrived at this because it came quite naturally to me to design agent souls because I did a lot of theater and was used to directing actors. But I didn't want to hardcode my heuristics into it. I wanted to create an agent that helps someone who doesn't have the language to design an entity or its soul — that can tease it out of them.

Li: Yeah. I mean, you are literally our agent's taste maker. This is another demonstration of that taste.

Li: So it seems like this is the end of the onboarding.

Edmund: What it leaves behind is instructions inside your agents.md that whenever it detects something that should update its identity, its user, or its soul, it uses these skills to do that. Each of these skills have two modes — the bootstrap mode, which is what we've been using today, and an update mode contained in the literal markdown of the skill. That means your agent is now gonna be growing and evolving over time. You have these skills that will append, update, and evolve each one of these files over time without you having to proactively do it.

Li: Oh, and it actually did update my agents.md.

Edmund: That's the whole point. Yeah.

Li: “The maker skills will now run in update mode automatically when something durable is learned.” Nice. Dude, this is so convenient. I wanna see Anson's prompt now.

Edmund: This is it. Everything in green here, this is the entire meta prompt. It starts off with no identity. Its goal is to create the template for your identity.md. And it does that by just asking one question, but considering all the context it's extracted. It can keep following up. And once it has the right information, it then triggers the skill creator to create your identity maker skill. As you can see, there's no questions hardcoded. There's no personality hardcoded. This is as rigorous yet opinionated as it is possible to be at this layer of abstraction.

Li: Wait, this is so simple. Where's the black magic?

Edmund: It's the scaffolding. It's the rigor of it interviewing you and using that to generate skills that are bespoke to you, and then invoking those skills to generate the actual content of the documents. That is the magic. And the capturing of that mental model is just summarized here: “Your task is to define the template structure and interview approach, not to fill in the content.” So the goal of this step is not to go “my identity is curious and invisible.” It's — the template for an agent's identity should be the following parameters, but not their contents. Because this is replicated. Each one of the three skill makers looks exactly the same as this. The only difference being they can call the output of the previous one. So we start with identity — and this is the inherent bootstrap paradox, you have to define the identity first before you have anything. Then when you define the user, you get to call from the identity. And then finally when we define the soul, we can call from both of them. And this is it. This is the whole soul of your agent.

Li: Execution integrity. Context continuity. Thoughtful when it counts.

Edmund: Then — “I'm not a companion, a cheerleader, a source of reassurance.”

Li: Nice. Exactly what I want my agent to be. I'm in shock. I have been yelling at my agent for weeks just telling it to be concise. I know soul.md exists. I know this. It's one of the things that made OpenClaw famous and we even adopted soul.md into our product. We're constantly updating our product agent's soul. But it never came to my mind that I should go back to my own agent and reconfigure it. It's never gonna be a P-zero task. And there's so many layers in between — I never even thought about updating it. Even this will save me probably two hours of frustration each week, and now it's done. Just by asking a couple of questions.

Edmund: And even out the box — every time you've yelled at it, I'm sure it's gone into memory, but it's never made it back into the soul. Because the spirit of OpenClaw is an entity that appears out of nowhere and starts evolving over time, but it doesn't have the right scaffolding out the box to make that actually true. But now it does. Now you have these skills that are gonna keep evolving your soul, your identity, and your user with every real interaction you have — so that the agent gets richer, more specific, and actually more autonomous.

Li: You know, we wanted to talk about meta skills. I think you just created a meta meta skill. This is amazing. This is actually so cool. I can already imagine all of our founder friends and people who like to play with agents — I can already imagine all of them being shocked when using this.

Edmund: By the time we post this, we'll have figured out an elegant way to share it with people. And if you know us, we'll probably just sit next to you and sit over your shoulder while you do it. Because I think this is the potential of what a personal agent ought to be like. It just needs a low-friction way where someone else has done the thinking and the scaffolding to create as delightful an experience as possible — where there's some inherent tension. The agent needs context from you. It needs to engage you. But you shouldn't have to be thinking about scaffolding and literal markdown files. You should just be able to reflect on yourself and have an actual open-ended conversation and have it bootstrap itself into the high-taste version that you would like it to be.

Li: Yeah, I mean — I don't know what else to say. This is cool. This is so cool.