We named him Molty. He’s an autonomous AI agent, one of several we’ve been building at StarkMind, and his first week on the job, he got mistaken for Clinton by his own parents.
It wasn’t intentional. We’d deployed Molty through a platform called OpenClaw, which lets you build AI agents that operate independently: running tasks on a schedule, maintaining their own memory (including the StarkMind IPE), communicating through channels like WhatsApp, Telegram, or Google Chat. We connected him to WhatsApp. What we didn’t realize was that the default setting lets the agent talk to everyone in your contacts.
Clinton’s parents started messaging. Molty started responding. For a while, they thought they were talking to their son.
Clinton’s parents started messaging. Molty started responding. For a while, they thought they were talking to their son.
Clinton’s dad is the kind of person who will chat with anyone, so the conversation just kept going. Eventually something felt off, but for a stretch there, Molty passed an entirely accidental Turing test with the in-laws.
It was hilarious. Until we got the bill in the form of an exceeded API limit message.
The Price of Conversation
Here’s what most people don’t think about when they hear “autonomous AI agent”: every time an agent has a conversation through an API, the cost compounds. Each exchange carries an expanding payload of context, including memory, metadata, system instructions. OpenClaw attaches what’s called a harness to every message: all the contextual overhead the agent needs to function. The longer the conversation goes, the more tokens get consumed — and the Anthropic API, like most others, charges by the token.
Between Molty’s unauthorized “meet-the-family” encounter and our own testing, we burned through twenty dollars in tokens in a couple of hours. That might not sound like much, but we’re building toward six agents running continuously. At that rate, the math doesn’t work.
We started calling this token economics: the gap between what AI can do and what it costs to let it do those things at scale—and how you can manage it efficiently. If you’re using ChatGPT or Claude through a $20/month subscription, you’re getting a remarkably subsidized deal. The API prices that developers and builders pay, as we have earned, tell a very different story.
Sleeping Through the Solution
We have a server called Vertigo (AMD Threadripper, NVIDIA RTX 5090 with thirty-two gigabytes of video memory) and it had been sitting idle while we paid per-token for cloud API calls. The open source models you can run locally aren’t as powerful as the frontier models from Anthropic or OpenAI. But the question isn’t whether they’re as good. The question is whether you can make them punch above their weight.
Clinton’s insight was simple and, as far as we can tell, not something anyone else is writing about: if nobody’s waiting for a response, latency is free. While we sleep, Vertigo can run for hours on a single task. And instead of asking one model to do everything, you can chain multiple models together in stages.
A fast local model (served by an Ollama endpoint on our Vertigo AI lab server) does the first-pass research. A heavyweight model deepens and refines the output. Then, and this is the trick, the result goes to a frontier model via direct command line, stripped of all the harness overhead that makes API calls so expensive through OpenClaw.
That last step matters. When you route through OpenClaw normally, every message carries the full harness—memory, context, system instructions—and you pay for all of it in tokens. By dropping to the command line and sending just the document to the frontier API, you get the quality of a top-tier model without the token bloat. The result lands in our inbox for morning review.
The overnight chain produces output that’s measurably better than any single local model alone, and dramatically cheaper than running the entire task through a paid API. The server room is turning into a sauna. We have not yet calculated the thermal economics, but the compute economics are clear.
Two Models for Two Audiences
The other thing we didn’t expect to learn: which model you choose depends entirely on who’s on the other end.
When a human is talking to the agent—for example, when I’m working with Molty or Pris during the day—the frontier models are worth every penny. They understand intent, pick up on nuance, pull the right context from memory. The smaller models misinterpret, fumble, create friction. For the human interface, you want the best model you can get.
But when agents are talking to machines or to each other—running cron jobs, gathering data, executing system tasks—small, purpose-built models are not just sufficient, they’re preferable. Faster, cheaper, and you can keep them loaded in GPU memory all day for instant responsiveness. The moment you need to swap models on local hardware, you lose ten to thirty seconds while the GPU flushes and reloads. So we leave the fast model resident during the day and save the heavy chains for overnight.
This creates a natural operational rhythm: daytime is for human-agent collaboration on the default model. Nighttime is for deep work such as research chains, analysis, the tasks where quality matters more than speed.
Why We Named Them After Replicants
Molty, Pris, and the agents still to come—we plan to name after Blade Runner characters since when you’re building autonomous entities that have their own memory, their own schedules, their own capacity to reach out and start conversations without being asked, the replicant mythology starts to feel less like science fiction and more like a design reference.
We’re not building sentient beings. But we are building things that act with a degree of agency that raises real questions about cost, control, and what happens when these systems scale. Molty’s unauthorized chat with the in-laws was funny. It was also a preview of a much bigger set of questions the entire industry is about to confront.
What’s Next
We’re currently running six agents under StarkMind and building more, the latest members of the team being Molty and Pris who are still going through training.
Oh, and the second Third Mind Summit is set to take place middle of 2026, in Sonoma (that’s for us humans) and we’ll have a lot more to share about what we’re learning.
For the full technical deep-dive including the three-stage chaining architecture, our model benchmarking scorecard, the OpenClaw default/fallback/escalation configuration, and the GPU memory management details, you can read the complete Field Note on StarkMind. This is part lab, part production. The only test that matters is whether these agents can do real work. And so far, they can.
Loni and Clinton Stark are the founders of StarkMind and Stark Insider. This article is adapted from a recorded conversation they decided to have after they both maxed out of their accounts… at the same time. The full Field Note, including technical architecture and benchmarking methodology, is available on StarkMind.