Swap the Model, Keep the Agent
A useful way to tell whether you own an AI agent: change the model underneath it and see what happens.
If the agent forgets who you are, loses its instructions, or has to be reconstructed from scratch, then its identity was never in the parts you controlled. It was in the vendor's product, and you were borrowing it.
If the agent keeps working — same memory, same skills, same boundaries, same accumulated understanding of your projects — then the model was doing what a model should do: thinking, not being.
The model is an engine, not the self
This is the first condition of agent sovereignty, and it is the one people find least intuitive, because the model is the impressive part. It writes the words. It does the reasoning. Surely that is the agent?
But consider what actually distinguishes your agent from an identical installation belonging to someone else. Same code, same model, same version. The difference is entirely in:
- what it remembers about you and your work,
- the skills you gave it,
- the workspace and files it can reach,
- the permissions and rules you set,
- the conventions it has learned not to violate.
None of that is in the model. All of it is in state that can live on your side of the line. The model supplies capability; the state supplies identity. Swap the first and the second is untouched — provided the architecture kept them separate in the first place.
That is why Suzent supports many providers — OpenAI, Anthropic, Gemini, DeepSeek, Ollama and local models, and others — and lets you switch per session rather than per installation.
What has to be true for the swap to be cheap
"Model-agnostic" is a claim a lot of tools make. Three things determine whether it survives contact with a real migration.
Memory has to be model-independent. If what the agent knows is stored as embeddings from one provider's model, switching means re-embedding everything, and any drift in retrieval quality is invisible until it bites. Suzent's source of truth is Markdown; the semantic index is derived from those files and can be rebuilt. Changing the embedding model is a reindex, not a data loss.
Skills have to be prose, not prompts tuned to one model. Suzent skills are Markdown knowledge modules describing how to work in a domain. Documentation transfers between models. Brittle prompt scaffolding tuned to one model's quirks does not.
Capability differences have to be handled, not ignored. This is the honest caveat. Models genuinely differ — context windows, tool-calling reliability, vision support, instruction-following under long autonomous runs. A swap is a config change, but it is not a no-op. A smaller local model will not carry a long agentic task the way a frontier model does. Sovereignty gives you the freedom to choose; it does not make the choices equivalent, and any project telling you otherwise is selling something.
What this buys you day to day
Model independence sounds like insurance against a rare disaster. In practice it pays out constantly, in ordinary ways:
- Run a cheap fast model for routine work and a frontier model for hard problems, in the same agent, with the same memory.
- Move sensitive work to a local model without moving to a different tool or losing context.
- Adopt a new release the week it ships instead of waiting for a vendor to integrate it.
- Stop caring, structurally, about which lab is currently ahead.
That last one is the real dividend. When identity is independent of the model, the frontier race becomes something you benefit from rather than something you are exposed to.
The check
Question two of the sovereignty test: can I replace the model without resetting its identity?
It is worth actually trying, rather than trusting the marketing copy. Point your agent at a different provider and ask it something only your agent would know. The answer tells you where its identity was living all along.