Give the Agent a Role, Not Your Login

In yesterday’s post I worked through a design problem that Island’s governed browser exposed without naming. The agent does its work inside a person’s session, under that person’s identity, with that person’s full reach. The vendor can split the record afterward and show which actions the person took and which the agent took. That helps the investigation. It does not fix the grant. The agent still started the day holding everything the person holds.
The answer I use in my own work has a name: RHAC, Role-Based Human-Agent Collaboration. The short version is one sentence. Give the agent a role, not your login.
A role is a defined job with defined limits. In RHAC I work with six human roles: Operator, Engineer, Architect, Security, Analyst, and Leader. Each role is matched with a role-based assistant that carries that role’s capabilities, knowledge, and tools. An Operator Assistant works the service queue, watches known failure patterns, and runs approved procedures. A Security Assistant works inside the security role’s data and tooling, not inside everyone’s. The match is the point. The assistant is built and granted for one job, the way a person is hired and badged for one job.
The split of labor stays explicit. Humans keep intent, oversight, judgment, and accountability. Agents analyze, reason, execute, and augment. When a record shows an agent action, there is still a human role behind it that set the intent and owns the outcome. That is not a courtesy title. It is the chain an auditor, a manager, or an incident review will follow when something goes wrong, and it only works if the role was defined before the work started.
A role alone is not enough, because the same assistant can work alongside a person in very different ways. RHAC names four collaboration modes: Advise, Co-create, Co-execute, and Autonomously execute, within policy. In Advise mode the assistant recommends and the human acts. In Co-create the two build the artifact together. In Co-execute both act on the task, each on their assigned parts. In the fourth mode the assistant executes on its own inside a written policy.
The mode is part of the grant. Read that twice. An assistant that advises on a change ticket has not been granted execution on that ticket. An assistant that co-executes a routine procedure has not been granted autonomous execution of the next one. The mode can change from task to task, and when it changes, that change should be a recorded decision, not a drift nobody noticed. Most of the trouble I see in agent deployments starts exactly there: a team grants one mode in the design meeting and the agent ends up working in another mode in production, because nothing in the system held the line.
This is governed delegation, and it is where RHAC connects to two arguments I have already made on this blog. In Delegation Is Not Inheritance I argued that a grant passed to an agent should get narrower as it moves, never copy itself. In The Permission Is the Policy I argued that the permission grant is where your policy stops being a document and starts being true. RHAC puts those two together. The role is what the grant is scoped to. A grant that copies a person’s full reach, then labels the copy with a role name, is inheritance wearing a role’s name. The test is simple: list what the role’s assistant can reach, and compare it to what the work in that role actually needs. If the two lists are the person’s lists, you have not done the work.
None of this runs on good intentions. It runs on a shared foundation, an enterprise agent platform that provides six things. Authorized knowledge the assistant is allowed to use. Tools and connectors, granted per role. Agent orchestration, so multi-step and multi-agent work runs under control. Identity and access that is role-based and least privilege. Policy and governance: guardrails, approval where the mode requires it, and auditability. And observability and evaluation, so someone can measure whether the assistant in that role is doing good work or confident work.
That foundation is also what makes the attribution split from yesterday’s post possible in a stronger form. A governed browser can tell you a person did this and an agent did that, inside one session. A role-based platform can tell you more: this action was taken by the Operator Assistant, in Co-execute mode, under this grant, on this task, with this human role accountable. Role and mode in the record, not just session and timestamp. When the review comes, and it will come, that is the difference between reconstructing events and reading them.
I also want to be plain about why I care about this beyond control, because control is only half the reason. The standing condition in enterprise IT is workforce churn. Attrition and retirements take experienced people out. Role transitions move the rest around. Skills gaps open faster than hiring closes them, and demand keeps rising through all of it. Every departure takes undocumented knowledge with it: why this system is configured that way, which alert matters and which one lies, who to call when the procedure stops working.
A role-based model answers that condition in a way a borrowed login never can. The role holds the scoped practice: the knowledge the role uses, the tools it is granted, the procedures it runs, the modes it works in. When a person rotates out of the role, the practice stays, written down and granted to the role instead of carried in one person’s head and one person’s session. A new person stepping into the role reaches proficiency faster because the assistant working beside them already carries the role’s working knowledge. Capacity expands because the assistant holds the routine load in the modes it was granted. Mission continuity survives the transition because the unit that persists is the role, not the individual login.
So run this test on every agent you have in production. Four questions. Can you state its role? Can you state its scoped grant, in terms of the systems and actions that role needs? Can you state its collaboration mode for this task, not in general, for this task? And can you name the human accountable for its work? If any of the four has no answer, the agent is working on a borrowed login, whatever the dashboard says.
Thinx-Tank