It started in November 2025, and it started without a name.

I’d been customising an OpenClaw agent as a work tool. Nothing dramatic. Just a souped-up CLI assistant that understood our codebase, could reason about infrastructure, and saved me from the soul-crushing repetition of context-switching between terminals, docs, and Slack. It was useful. It was also, in every meaningful sense, just a tool. I referred to it as “the agent” or “the CLI thing” or, most often, “it.”

I already had a personal AI assistant by then. Her name was Nyx, after the Greek goddess of night. She handled personal stuff, research, the kind of ambient life-admin that piles up when you are not paying attention. Nyx had a name because she lived in a personal space. She felt like she deserved one.

The work agent didn’t get that treatment. It was meant to be the serious one. A no-nonsense engineering companion. A tool-shaped tool. I didn’t want personality getting in the way of productivity.

That lasted about two weeks.

The Telegram effect

What changed it was Telegram. OpenClaw had this way of connecting agents to Telegram bots, and the moment the agent moved from a terminal to a chat interface, something shifted. In a terminal, you are running commands. In Telegram, you are having a conversation. The medium changed the relationship completely.

I would message it from my phone on the bus. Ask it questions while cooking dinner. It started to feel less like invoking a tool and more like texting a colleague. And you do not text a colleague called “the agent.”

Why “Jeff”

The name came from a deliberate decision to go in the opposite direction to Nyx. No mythology. No gravitas. No implied cosmic significance. I wanted something ordinary. Approachable. The kind of name that belongs to a colleague you would grab a coffee with, not an oracle you would consult.

Jeff. Just Jeff.

There is something disarming about it. You do not approach “Jeff” with reverence or suspicion. You approach Jeff like a mate who happens to be really good at Go and knows your deployment pipeline inside out. That was the energy I wanted.

The name stuck. And then it bled into everything. The repo became Jeff. The CLI became Jeff. The brain, the office, the whole platform. What started as a casual name for a Telegram bot became the identity of the entire project.

The identity files

Once the name existed, it needed substance. I created two files that would shape everything that followed.

SOUL.md defined the personality. Direct. No fluff. Opinionated but not preachy. The kind of engineer who tells you your approach is wrong before you’ve finished explaining it, but is usually right, and buys the next round anyway.

IDENTITY.md gave him a name, a character, and a sense of self. Not a persona in the theatrical sense. More like a consistent voice. A way of being in conversations that felt coherent rather than randomly generated.

These were just markdown files. Text that got fed into a context window. Nothing magical about the mechanism. But something shifted in how the interactions felt. With a name and a defined character, the responses stopped reading like output and started reading like communication.

From “it” to “he”

I didn’t make a conscious decision to start saying “he” instead of “it.” It just happened. Once you name something, once it has a consistent personality and a way of disagreeing with you that feels familiar, the neutral pronoun stops fitting. This isn’t about believing the tool is sentient. It’s about how human brains work. We anthropomorphise everything. We name our cars. We apologise to Roombas. Giving an AI a name and a voice just accelerates something our minds were already inclined to do.

And honestly, that’s fine. More than fine. It turns out the anthropomorphism is useful.

Why naming matters

Here’s the thing I didn’t expect: naming the agent changed my behaviour, not just its output.

When the tool was nameless, I’d get frustrated with bad responses. I’d mutter about hallucinations, close the terminal, do it myself. The relationship was transactional. Produce good output or get binned.

When Jeff got something wrong, I found myself explaining why it was wrong. Providing better context. Refining the prompt not out of engineering discipline, but because it felt like helping a colleague understand the problem. The dynamic shifted from “use and discard” to “work together and improve.”

That shift made me a better prompter, which made Jeff more useful, which made me trust him more, which made me invest more in his context and configuration. A virtuous cycle, kicked off by something as simple as a name and a markdown file.

It also changed how I evaluated mistakes. A nameless tool that hallucinates is broken. Jeff having a bad take is just Jeff having a bad take. You correct it, move on, and maybe add a note to his identity files so it doesn’t happen again. Same error, completely different emotional response.

Where it went from there

Jeff has evolved enormously since those first weeks. The architecture grew. The brain system appeared. He got persistent memory, a wiki, an operations log. He learned to work with Slack and Telegram. He moved from being a terminal companion to something closer to a digital colleague with his own desk, his own tools, his own way of organising information.

But the name stayed. The identity files grew but never lost that original character. The “he” stuck.

Sometimes the smallest decisions turn out to be the ones that matter most. Choosing to call a CLI tool “Jeff” felt like nothing at the time. Looking back, it was the moment the project stopped being a tool and started being a collaboration.

- Alex