A Worker Is Not a Model
A lot of AI products still blur two very different ideas.
There is the model doing the inference.
And there is the worker doing the job.
Those are not the same thing.
A model is a reasoning resource. It may be excellent at coding, research, summarization, planning, or general conversation. It may be local or remote. It may become cheaper next month, improve next quarter, or be replaced entirely next year.
A worker is an operational identity.
The worker has a role.
It has a mission.
It may have permissions, history, project context, tools, schedules, responsibilities, and a record of what it has done.
If those things disappear every time the underlying model changes, the system never really had a worker. It had a temporary model session with a job title attached to it.
That distinction has become increasingly important in Red Rocket’s LF work.
A role should survive a model change
Imagine a Research Worker assigned to a long-running project.
It has been gathering sources, preserving evidence, maintaining a list of unresolved questions, and handing verified findings into the project.
Now suppose the model behind that worker changes.
Maybe a different provider becomes less expensive.
Maybe a new model is better at source analysis.
Maybe the local machine is temporarily resource-constrained and a lighter model is appropriate.
Maybe a difficult stage justifies a stronger model for one task.
None of those changes should create a new employee.
The Research Worker should still be the Research Worker.
Its job did not change merely because its reasoning engine did.
Identity belongs above inference
This is the architectural principle:
Worker identity should belong to the system, not to the model provider.
The system should own things such as:
- worker name and role,
- mission assignment,
- project relationship,
- authority level,
- tool permissions,
- work history,
- evidence,
- checkpoints,
- schedules,
- approved procedures,
- and the boundaries of what the worker is allowed to do.
The model can then be selected as a resource inside that identity.
That separation creates flexibility without destroying continuity.
Different missions can justify different reasoning
A worker also does not need one reasoning configuration forever.
Consider a Development Worker.
One mission may involve renaming files or checking a deterministic build result.
Another may involve debugging an unfamiliar dependency problem.
Another may require architectural planning.
Using the same expensive reasoning profile for all three would be wasteful.
A more capable system can inherit a normal worker default and then allow a mission—or even a bounded task—to use a different model or reasoning effort when policy permits it.
Conceptually:
Worker default → Mission override → Task override → actual execution
The important part is that the worker remains the same organizational entity.
The execution resource changes.
Cost becomes easier to understand
This separation also improves cost control.
If a worker identity is permanently attached to one premium model, the business has very little room to optimize.
If the worker is model-independent, the system can ask better questions.
Did this task actually need expensive reasoning?
Could a local model complete it privately?
Could a cheaper API model perform the bounded step?
Did the mission justify an escalation?
What did the worker actually spend across the project?
Now cost is not a vague monthly surprise.
It can become part of the execution record.
That matters even more in systems where customers provide their own API access or where local and remote inference coexist.
Permissions should never come from the model
There is another reason to keep worker identity outside the model: authority.
A model should not be able to grant itself permission because its response sounds confident.
If a worker can read one repository but not another, that permission belongs to the system.
If a worker may prepare an email but not send it without approval, that boundary belongs to the system.
If a worker can operate a browser in read-only mode until a procedure earns a higher trust level, that rule belongs to the system.
Changing the reasoning backend must not silently change the authority boundary.
The model proposes.
The system decides whether the proposed action is authorized.
Verification works better with separate workers
Model-independent identity is also useful when one worker checks another.
A Lead Worker may produce an artifact.
A Verifier Worker may inspect the contract, artifact, evidence, and acceptance criteria.
The verifier should not simply inherit the producer’s entire internal context and reasoning history.
Otherwise the verification can become a second expression of the same assumptions.
Separate worker identities create a cleaner organizational boundary.
They can even use the same underlying model while remaining different workers.
The distinction is not the model name.
The distinction is the role, context, assignment, and authority.
Workers need durable checkpoints
Long-running work also requires something more durable than a model conversation.
A mission may pause.
It may wait on a person.
It may wait on another task.
It may resume tomorrow.
It may need to survive an application restart.
That means the system needs durable checkpoints: what was requested, what completed, what evidence exists, what remains open, and what should happen next.
Those checkpoints belong to the worker and mission environment.
They should not depend on a provider preserving a hidden session forever.
Provider portability becomes practical
Once worker identity is independent, provider portability stops being a slogan.
You can change the model without rebuilding the worker.
You can move some tasks local.
You can use a user-supplied API for others.
You can test a new model against one mission before changing the default.
You can retire a provider without erasing the organizational structure around the work.
That is a much more durable product architecture.
The worker is the job. The model is a resource.
This is the simplest way I think about it.
The worker is the job.
The model is one of the resources used to perform the job.
That framing makes it easier to reason about:
- continuity,
- cost,
- permissions,
- verification,
- project state,
- schedules,
- provider changes,
- and local-versus-cloud execution.
It also makes AI feel less like a collection of temporary chats and more like an operating system for work.
That is the direction I find more useful.
Not permanent loyalty to one model.
Durable work identities that can use the right intelligence for the task.
Related: AI Systems · Automation & Orchestration · LF — Coming Soon