The Identity Problem
We built on top of Hermes and OpenClaw before building Transistor. We also studied the internal scaffolding revealed by the Claude system prompt leak. Each system solved a real piece of the problem. Each one left a specific gap we hit directly. This is what we learned, and what we built to close it.
Hermes remembers tasks. OpenClaw remembers events. Claude has identity baked into its weights. But none of them know you across models, devices, and time, because they store memory and identity inside the agent rather than underneath it. As models converge in capability, the real question stops being which model is best and starts being whose operating system you are living on. Transistor puts memory and identity at the platform layer, so the model is swappable, your data is yours, and you never get locked in.
Memory exists. The right kind does not.
Several AI agent systems have solved the problem of persistence in a narrow sense. Hermes remembers which tasks it has learned to perform. OpenClaw maintains a detailed memory of events, facts, and procedures. These are real advances. We built on both of them, and we know firsthand what they get right and where they stop.
But there is a more specific problem that none of them fully address: persistent, person-indexed identity that travels across models, devices, and time. The question is not whether an agent can remember a task. It is whether the agent, regardless of which model powers it, knows you well enough to work with you rather than just for you.
Most agent memory is organized around work: what was done, what was learned, what comes next. This is useful, but it is not the same as understanding a person. The way you communicate, what you find tedious, how you make decisions, which contexts require which tone, the things you have already ruled out before you even ask. That kind of context does not emerge from task logs. It requires a different kind of substrate.
The question is not whether an agent can remember a task. It is whether the agent, regardless of which model powers it, knows you well enough to work with you rather than just for you.
To understand where existing systems fall short, we mapped the three most architecturally interesting approaches and traced exactly where each one hits its limit.
What we studied
Hermes introduces a self-improving loop: the agent reflects on its own performance after each task, synthesizes that reflection into a new skill, and persists that skill across future sessions. This is a genuine architectural advance. Rather than relying entirely on the base model's parametric knowledge, Hermes builds a growing library of learned procedures specific to its operating environment.
Hermes is optimized for autonomy over relationship. Its memory is task-indexed, not person-indexed. The system accumulates knowledge about how to do things, but not about who it is doing them for. Over time, a Hermes agent becomes better at tasks in general, but not necessarily better at understanding you specifically.
OpenClaw treats the agent as a long-running process with a persistent action graph. Its memory model is the most cognitively sophisticated of the three: it separates episodic memory (what happened), semantic memory (what is known), and procedural memory (how to act). This tripartite structure mirrors how cognitive scientists describe human long-term memory, and it produces agents with noticeably more coherent long-horizon behavior. Transistor was originally built as a UI layer on top of it.
Because memory and execution share the same process, moving between devices or resuming after a pause introduces consistency problems. We encountered these directly when building Transistor across Mac, Windows, iOS, and Android. The architecture was designed for a single long-running session, not for agents that need to be everywhere at once. That gap is what we set out to close.
The most revealing aspect of the leaked Claude system prompt was not the safety guidance. It was the identity scaffolding. Claude is given an elaborate internal self-concept: a set of values framed as constitutive rather than instructed. Anthropic's hypothesis, confirmed by the leak, is that stable identity produces more coherent behavior. An agent with a clear sense of what it is produces more consistent, trustworthy, and nuanced output than one operating from a flat instruction set.
This identity lives inside the model. It is baked into weights at training time and cannot learn from any individual user. It does not update between conversations. It resets. The model knows what it is in general, but it cannot know what it is to you.
The synthesis
Reading these three systems together, a pattern emerges. Hermes solves skill accumulation. OpenClaw solves memory structure. The Claude scaffolding solves identity stability. But none of them solve all three, and none of them solve the problem that connects all three: the soul of the agent should not live inside the model.
If identity lives in the weights, it cannot be personalized. If memory lives in the execution process, it cannot be synced. If skills live in a task-indexed store, they cannot be organized around the person who uses them. Each of these architectures treats the model as the primary artifact. We think that is the wrong unit of analysis.
The model is the intelligence. The platform is the person. These two things should be separate, and only one of them should be persistent.
The Transistor architecture
Transistor separates three concerns that existing systems conflate. Each layer is independently swappable, independently persistent, and independently queryable.
The consequence of this separation is significant. A Claude-powered Transistor agent and a GPT-powered Transistor agent will converge toward similar behavior over months of use, because they share the same memory substrate, the same skill library, and the same identity layer. The model is a detail. The platform is what accumulates.
This also means that if a better model ships tomorrow, you can switch to it without losing anything. Your agent's history, preferences, skills, and identity carry forward intact. The relationship is with the platform, not with the weights.
Why this produces better agents
Agents with stable, person-specific identity produce qualitatively different output. They do not ask you to re-explain your preferences. They do not suggest tools you have already rejected. They calibrate their tone, their detail level, and their initiative to what they have learned about how you work.
This is not a capability improvement in the conventional sense. The underlying model has not changed. What has changed is the substrate the model is operating on. A highly capable model operating on rich, structured, person-specific context produces output that feels categorically different from the same model operating on a blank session.
The research literature on human-AI interaction supports this framing. Users consistently rate AI systems higher on trust and utility when those systems demonstrate memory of prior interactions, even when the underlying model quality is held constant. Continuity, not capability, is the primary driver of perceived intelligence in personal AI contexts.
The convergence problem
There is a broader shift happening that makes the architecture question more urgent than it might appear. The top AI models are getting closer to each other. The gap between ChatGPT, Claude, and Gemini in early 2024 was meaningful. Today it is mostly nuance. A year from now, the leading models will likely be interchangeable for most tasks, distinguished only by price, speed, and narrow specializations.
When models converge, the question "which model should I use" becomes less interesting than "whose system am I living on." OpenAI is building an operating system. Anthropic is building an operating system. Google is building an operating system. Each of them wants your memory, your history, and your context to live inside their product, because that is what creates lock-in. If your two years of conversation history live inside ChatGPT, you are not really free to leave. They have your past.
When models converge in capability, lock-in stops being about intelligence and starts being about who owns your memories.
Transistor inverts this dynamic. Your memory and identity live in a layer you control, not inside any single provider's product. This means models have to compete for access to your context rather than competing to trap it. You pick Claude because it is the best model for your use case today. You switch to GPT-5 when it ships tomorrow. You run a local model on the weekends. None of it affects your agent's accumulated knowledge of you, because that knowledge was never theirs to begin with.
Model providers compete on price and quality. You get flexibility and ownership. That is a structurally different relationship with AI than any of the incumbents are offering, and it becomes more valuable the more capable models get, not less.
The future of personal AI is not a chatbot you start fresh every morning. It is an operating system that runs alongside your life, accumulating context the way a trusted colleague does over years, not milliseconds.
Transistor is that operating system.