# Circle the Agent

Put an agentic system on a whiteboard and circle the agent.

The answer depends on why you picked up the marker. Evaluation, authorization, incident response, and product design may each require a different boundary.

That is how one word ends up naming the model, harness, running service, task, and named assistant.

There is no settled definition that works in every context. This series asks something narrower: when an agent acts, what exactly are we identifying, governing, and holding accountable?

That narrower question matters because technical objects have different lifetimes. A model can be replaced without changing the product name. A process can restart while a task continues. A role can remain approved while an implementation is pulled from production. If all those changes are called “the agent,” the system loses track of what persisted and what acted.

## What persists?

Take a support assistant that can read an order system and, with the right approval, change an order. We can learn more by swapping one part at a time than by arguing over a definition in the abstract.

Start with the model. Replace the model with a newer one while keeping the same product role, instructions, tools, and customer task. Is it the same agent?

For the customer, perhaps. The same assistant appears in the same conversation and still claims to help with the same kind of problem. For the implementation, no. A model swap changes behavior that may need testing, review, and a fresh policy decision. The replacement may interpret instructions differently, choose tools differently, or fail in a new way. Product continuity does not erase implementation change.

This is a useful first separation. The logical product role, such as `support-order-assistant`, can persist through a model replacement. The implementation does not. A system that treats the role as proof that the implementation is unchanged has made the product label do security work it cannot do.

Now swap the harness. Keep the model and product role, but replace the code managing prompts, tool results, retries, memory, and stopping conditions. One harness may follow a fixed path. Another may let the model choose the next tool. Anthropic’s distinction between workflows, where code determines the path, and agents, where the model dynamically directs its process and tool use, is helpful here ([Building effective agents](https://www.anthropic.com/engineering/building-effective-agents)). It tells us where discretion lives, not that the harness, model, and task share an identity. Change the harness, and a product team may still see the same assistant while an engineer must review a different tool-selection surface.

Now restart the running execution. The process crashes and comes back. The new process has loaded the same configuration and recovered some state. Is it the same agent?

The original execution ended. A new execution is running. That matters for debugging, evidence, and stopping one live process, but it does not settle whether the customer’s task continued. Continuity depends on a durable task or session identifier, persisted state, still-valid authority, and explicit resume semantics. A restored transcript is not, by itself, a lifecycle rule.

Try a bounded task or session next. Keep the same model, harness, service, and tool catalog, then move from one customer conversation to another. The product may present one assistant and the platform one service, but the task has different purpose, inputs, state, budget, and possibly permission. A task or session needs enough identity to distinguish one piece of work when scope, evidence, stopping, or authority depends on it.

Finally, swap the logical product role. Retire the support assistant and launch a claims assistant on the same infrastructure. The service and much of the implementation may persist, but the role, purpose, tools, and approval boundaries have changed.

The swap tests do not reveal one winner. They reveal which boundary a question requires. The model answers what behavior is in play. The harness answers how state and instructions become choices. The running execution answers which live instance is operating. The task or session answers which bounded work is underway. The logical role answers what enduring job the system performs.

A glossary cannot choose among those boundaries. The [NIST glossary entry for agent](https://csrc.nist.gov/glossary/term/agent) records usages including a program acting on behalf of a person or organization and software that interacts with its environment toward a larger goal. Neither tells an authorization system whether to stop a process, end a task, or withdraw a role’s capability.

The practical rule is simple: before calling something the agent, ask what must survive the swap. If the model changes, implementation identity matters. If the process restarts, execution identity matters. If the customer changes, task or session identity matters. If all can change while the product still offers the same assistant, the logical role is the circle that persisted.

## Where does authority come from?

Persistence still does not tell us who is allowed to act. That requires a second question: where does authority come from?

A delegated agent acts through authority supplied by someone or something upstream. A user may approve a refund. A parent agent may assign a research task. An administrator may configure a support policy. An organization may authorize a scheduled process to reconcile records. In each case, the agent receives a bounded ability to act. It does not create that ability by describing a goal confidently.

The word *autonomous* can make this sound more mysterious than it is. An autonomous agent has no live human approving every step. It may choose tools, sequence actions, and continue toward an assigned goal without waiting for a person. It is still not self-authorizing. Its authority comes from policy, an administrator, an organization, a schedule, or another actor that established the limits under which it may operate.

That distinction matters when the system moves from one task to another. A support service may have a standing role that permits it to handle refunds under certain conditions. A particular task should still carry the narrower scope that applies to this customer, order, amount, and time. The service’s identity says what software is calling. The task’s authority says why this call is allowed and where its limits came from.

Identity and authority therefore cannot be collapsed. Identity answers which subject a system recognizes. Authority answers what that subject may cause, under which constraints, and on whose grant. A credential is evidence presented at a boundary. It can help a service recognize a subject, but possession of the credential does not explain the purpose of the current task. Nor does a valid role prove that every action selected by a running execution is within the authority granted for this case.

This is why a task or session may need to become a principal, or at least a first-class handle that policy and evidence can name. Consider one persistent host serving thousands of conversations. The host identity is useful for deciding which software may connect. It is too broad for revoking one compromised task. The user identity is useful for identifying the person who initiated a conversation. It is too broad if the user approved one operation but not every operation the assistant can imagine. A task-level principal sits between them. It lets the system say: this bounded actor is operating in this context, with this grant, until this point.

That principal need not be universal. A low-risk drafting tool may not need one. A long-lived service may use a run record rather than minting a protocol subject for every step. The design question is whether the system needs to govern bounded work independently from its host, user, and role. When a task can spend money, disclose protected information, or change durable state, that distinction becomes difficult to avoid.

One emerging protocol makes this choice explicitly. The [AgentAuth v1 draft](https://agentauthprotocol.com/specification/v1.0-draft) chooses a runtime actor scoped to a conversation, task, or session beneath a persistent host. That is useful because bounded work gets its own place in registration, capability, lifecycle, and revocation instead of being inferred from a shared host credential or user session. AgentAuth is choosing a protocol boundary for a particular governance problem, not proving that every deployment should use it.

Its delegated and autonomous modes offer a concrete example of the distinction. In delegated mode, the runtime actor can be understood as carrying authority from an upstream actor. In autonomous mode, it can operate without a live human in the loop. Neither mode makes the runtime actor the source of authority. The protocol vocabulary can help describe how the actor operates, while the surrounding system still has to decide who granted its capabilities, what limits apply to this task, and what happens when that grant expires.

The broader lesson comes from our reasoning before any protocol enters the picture. An agent is a useful role word laid over several technical objects. The logical role says what job the system is meant to perform. The implementation says how it currently performs it. The workload says which software is running. The run says which bounded execution is underway. The credential says what evidence crossed a boundary. The authority says who or what supplied the right to cause an effect. Those facts may be represented together in a deployment. They should remain distinguishable when identity, permission, lifecycle, or accountability depends on them.

This opening chapter is not trying to solve universal agent ontology. It is deciding where the questions attach. The next writings separates the identities hidden inside “the agent”: logical role, implementation, workload, run, credential, and authority. Later writings take up delegation and accountability, where the cost of confusing those circles becomes harder to ignore.

For now, return to the whiteboard. The circles do not need to merge before the system can work. They need labels, boundaries, and a clear answer to what each one is allowed to mean.

## Sources

- [NIST Computer Security Resource Center Glossary: Agent](https://csrc.nist.gov/glossary/term/agent)
- [Anthropic: Building effective agents](https://www.anthropic.com/engineering/building-effective-agents)
- [AgentAuth Protocol: Specification v1.0-draft](https://agentauthprotocol.com/specification/v1.0-draft)
