I open Telegram and ask my agent to develop software. It has been a long time since I looked at the code anyway, and I still haven't found a simpler, more responsive setup for development, whether at the office, at home, or out somewhere.
All I have to do is repeat a loop: tell it what I want to build, what bothers me about the current result, and what needs to be verified before we can call it done. Unless I'm in public, I barely type. I just press the microphone button and pour out my thoughts as they come. “No… cancel that last thing. Let's go this way.” Even the traces of changing my mind, as if talking to myself. Speaking is more than three times faster than typing, but there is another advantage: the agent follows my train of thought better when I let it hear my thoughts before I've organized them, rather than giving it polished sentences.
I develop with Hermes Agent. Because recurring tasks automatically become skills, something I had to explain in several sentences last month takes just one sentence today. That structural advantage is probably what helped it overtake OpenClaw to become the most-used agent.
The biggest difference between today's agentic development and the way I worked until late last year, launching Claude Code or Codex directly in a terminal, isn't the model's intelligence. It's that my work memories and development habits, tools and instructions for using them, completion criteria, and ways to recover from failure are already connected on top of the model. Within a single run, this layer coordinates which models and tools to call, which specialist agent to hand work to, what context to pass along, and where to stop and ask me for confirmation. This is the execution control the industry calls orchestration.
If the model is the brain, this layer decides which memories it wakes up with today, what to watch out for, and where to stop. I can swap in a better model whenever one comes out. But the ways of working we've developed together aren't so easily replaced. The center of gravity of personalization lies not in the model, but in what accumulates outside it.
So the thing I say most often to my agent isn't a request for a new feature.
“Fix the structure so you don't make that same mistake next time.”
Then the agent does more than correct a single wrong answer. It looks back to see whether it lacked memory, whether the rules were vague, or whether the completion criteria were loose. It revises its memory and skills and adds regression tests. At some point, my agent began rewriting its own operating rules and recovery logic, sometimes even the core code of Hermes itself.
When I moved from OpenClaw to Hermes this spring, there was no way to connect my five agents—Zeon, Sion, Mion, Sano, and Raon—to their own Telegram bots. So I modified the code directly to let a single gateway handle multiple profiles, with each bot loading its own personality, memory, and sessions. If the wrong account came in, I blocked the response entirely rather than routing it to another bot. Once memories get mixed up, the premise of personalization falls apart. Hermes's official implementation was made public on June 18 and included in the next day's release. Now the official version also lets one gateway manage bots across multiple profiles when you enable the option. We eventually arrived at the same place, but in the meantime, my own code filled the gap.
I also changed the tool that calls several frontier models at once. I set a timeout for each call so one slow model wouldn't stall everything, and kept the answers that arrived first instead of discarding them. To address the problem of thinking a task was finished when work remained, I added a guard that prevents it from declaring completion while there are unfinished items. When a long task gets interrupted, I made it always leave behind its reasoning and intermediate results. Each time we encountered the same failure, it wasn't just the memory that grew. The code for handling the next failure changed.
After countless changes like these, the Hermes I use has drifted quite far from stock Hermes. It started from the same seed, but it has grown into a different branch, fed by my nagging and trial and error. MemKraft, the agent memory system I built myself, doesn't just store what was decided. It also records why a decision was made, how it turned out, and how long that information can be trusted. What I review is less the code itself than the reasons for the changes.
As this continues, the definition of software personalization will change considerably. Until now, personalization meant choosing things like icon layouts, background colors, and keyboard shortcuts within finished software. When you live with an agent, experience doesn't remain only as memory. That memory changes rules, creates tests to verify them and new tools, and overhauls recovery logic and the codebase itself. Settings retain your preferences. Code retains the way one person has failed and recovered.
That is why orchestration alone is not enough to describe it. Orchestration adjusts the sequence and branches within a given run. What I'm seeing is the next stage: the memories, rules, and code surrounding that run move into their next version through experience.
I want to call this branching a personal Agent Lineage. Agents that start from the same foundation translate one person's choices and failures into forms that can be verified and reversed, branching off into lineages of their own.
Then the assumption that everyone uses the same kind of agent no longer holds. An update is no longer a matter of overwriting everything with a finished new version. It becomes a merge between the shared functionality the platform has fixed and the changes I have cultivated. Even if everyone installs the same Hermes 2.0, one person's agent checks three times before making a payment, another's breaks work into smaller pieces, and another's asks a question first when a request is ambiguous. It isn't just the screen that differs. Parts of how they work differ too.
The role of agent platforms changes completely as well. Instead of distributing finished products, they become places where lineages grow. They need to accept security updates to the shared foundation while preserving rules that have changed to reflect me. They need to merge personal code with the official version when the two conflict, and selectively roll back changes learned in error while keeping the memories. Their competitive strength will come less from the number of features than from their ability to safely manage inheritance, merging, verification, and rollback across millions of branching lineages.
This structure, which I first encountered in development, will spread into everyday life. Schedules and relationships, travel and purchases, health and work are now scattered across different apps. A personal agent follows a person between them, stitching their context together. The route they disliked on their last trip and their habit of not making plans the day after a long meeting meet in the same memory. As memories accumulate, behavior changes. As behavior repeats, rules and code emerge that fit only that person.
Even two people who start with the same agent will get entirely different answers to the same request a few months later. “Pick a place I'd like to stay this weekend.” One person's agent books a small hotel in the old city center without even a view. What stayed with that person from past trips was a bakery in an alley at dawn and an old bookshop. Another person's agent chooses a secluded place by the sea with no restaurant nearby. It remembers that their favorite part of the last trip was the afternoon they canceled every plan and just listened to the waves. Once different records of life sit behind the same sentence, the right answers diverge too.
Paradoxically, the more software branches off for each person, the more important the shared foundation becomes. To take real action across services, identity and permissions, payments and records, auditing and undoing must share a common grammar. Personal code may differ, but the points where it connects must be solid. Today's SaaS is also more likely to recede behind the screen than disappear, becoming the foundation of official records and accountability that agents rely on.
At that point, the most important question won't be which model you use. Who owns the rules and code that have changed with me, the lineage formed through failure? Can I take all of it with me when I move to another platform? A good platform won't be one that sells the single smartest agent. It will be one that ensures the lineage that has grown differently with each person belongs to that person to the end.
I press the microphone button. “No, cancel that.” One hesitation, added without thinking, is becoming a memory, becoming a rule, and changing a line of code that forms the agent's bones.
