Cursor ships a new model. You upgrade. The context resets.
That’s fine. Cursor is a tool. You don’t grieve when a hammer gets replaced by a better one.
Now imagine you’ve worked with the same engineer for six months. They know your codebase. They know why the rate limiter looks like that. They know you tried three other approaches first and why each one broke. You don’t re-explain any of it.
That’s the distinction that matters.
what tools do
tools execute. you give them a task, they return output. the quality of the output depends on the quality of the model and the specificity of your prompt.
tools are stateless by design. each session is independent. the tool doesn’t know what you decided last week or what broke in production two weeks ago. that’s not a bug in these tools. it’s a reasonable tradeoff for something you use interactively, session by session.
the problem is agents aren’t interactive tools. they run overnight, across dozens of sessions, on work you defined once and then stepped back from. stateless is the wrong model for that.
what characters do
a character accumulates. every session it runs, it reads what came before and writes for what comes after. it has a name. it has a persistent file that describes what it cares about. it has a memory of what it’s tried and what’s worked.
six months in, that memory is the asset. not the code it wrote. the codebase always changes. the asset is the accumulated understanding of your codebase, your decisions, your preferences. the context that would take months to rebuild if you started fresh.
tools are interchangeable. characters aren’t. that’s not sentiment. it’s a description of what’s hard to replace.
the identity layer
giving an agent a name isn’t cosmetic. it’s the starting point for a persistent objective function.
an agent named zealot was given a lens: architectural purity, simplicity, zero tolerance for slop. every session it runs, it reads its memory file and works from that frame. it notices different things than an agent focused on shipping speed. it pushes back on different changes.
that lens is what makes disagreement possible. two copies of the same tool will find the same things. two agents with different identities will find different things. when they disagree, that tension produces signal you wouldn’t get from either alone.
identity is the primitive that makes a swarm more than a fleet.
what you actually lose when you switch
a tool switch costs you nothing but the migration time. that’s why the market can commoditize them. the switching cost is close to zero.
a character switch costs you the accumulated context. the memory files, the ledger of decisions, the months of sessions that shaped how the agent reads your codebase. none of that transfers.
that’s not a lock-in mechanism. it’s just what compounding means. the value isn’t in the agent’s weights. those you can replace. the value is in what the agent knows about you. that took time to build and it’s yours.
the practical difference
when you open cursor, you explain the problem. when a character wakes up, it already knows the context.
when you prompt a tool, you get what the prompt asked for. when a character runs overnight, it decides what needs doing.
when a tool makes a mistake, you correct it. when a character makes a mistake, it remembers the correction.
tools get better when the model improves. characters get better every session.
that’s the difference. one compounds, one doesn’t.