Every security leader has now been asked some version of the same question: should we let AI agents make decisions about access? Put that way, it is the wrong question. Nobody is proposing that a model hand out production admin on a whim. The real question is narrower and more useful: for each specific job in the access lifecycle, how far should software be allowed to act before a person looks, and how do we take back anything it got wrong?

InsightKeys answers that with an autonomy dial: four levels, set per agent, per organisation, under a ceiling the deployment fixes. This post explains the levels, the defaults and the reasoning behind them, how every agent action stays reversible and on the record, and what should always stay with a person.

In short

  • Four levels. L1 Draft (a person does the work), L2 Ask first, L3 Act and tell (can be pulled back), L4 Act.
  • Set per agent, not for “the AI”. Narrowing a permission is low-regret; revoking a live session is not. They deserve different settings.
  • A ceiling above the dial. The deployment caps how high any organisation can turn any agent, so a configuration mistake cannot grant more autonomy than was agreed.
  • Every action is in an inbox and the audit trail. Approve, reject or undo, with the reasons the agent gave and the records it read.
  • The broker is the backstop. Agents work in the control plane; the customer-run broker enforces its own local policy whatever any agent decides.

Why “should agents decide?” is the wrong question

Access management is full of small, repetitive judgements. Does this sentence mean the payments database or the payments account? Which six of these two hundred actions does this task need? Is this request low risk given who is on call and which incident is open? Did that session do anything outside what was asked? Has this administrator role been used in the last 90 days?

Each judgement is made today by a person, usually badly, because there are too many of them and the person has other work. The result is the familiar pattern: broad roles because scoping is tedious, rubber-stamped approvals because reading every request is impossible, and standing access that nobody removes because nobody has time to check whether it is used.

Agents are good at exactly this kind of work: read the records, apply a rule, explain the reasoning. They are not good at knowing that exports are frozen during an incident, or that a contractor’s engagement ended yesterday. The design task is to give each agent the authority that matches its kind of judgement, and no more.

There is also an accountability point that boards and regulators will ask about. When an access decision goes wrong, someone has to answer for it. With an autonomy dial the answer is clear at every level: at L1 and L2 the person who acted or approved; at L3 and L4 the people who set the agent to that level, inside a ceiling a named executive agreed. That chain is written down in the settings and the audit trail, not implied.

Finally, autonomy is not all or nothing over time either. An agent can start at L2 while the security team learns how it behaves, move to L3 once its record is good, and drop back to L2 the week a major change lands. The dial is meant to be turned.

Four levels, defined

LevelNameWhat the agent doesWhat a person does
L1DraftPrepares the work: a proposal, with its reasons and evidenceDoes the work, or not
L2Ask firstPrepares the decision and asks before actingApproves or rejects each action
L3Act and tellActs, tells the person, and lets them pull it backReviews afterwards; undoes if wrong
L4ActActs on its own; the action is recordedAudits the record

The levels are set per agent and per organisation, and capped by a ceiling fixed for the deployment. If the deployment ceiling is L3, nobody in the organisation can set any agent to L4, however the settings page is used. That separation matters for governance: the people who agree the risk appetite set the ceiling once; day-to-day settings move only beneath it.

Agent settings showing the L1 to L4 levels, with Intake not governed, the least-privilege scoper and risk and approval at L3 act and tell, and session watch at L2 ask first, each with 30-day run statistics
The dial, per agent. Each card says what the agent reads, what it proposes, its level and its 30-day record: runs, applied, approved, rejected, reverted and accepted.

The agents and their defaults

The defaults follow one principle: the more reversible and bounded an action, the higher the default; the more it affects a person’s work in progress or permanently changes the estate, the lower.

AgentDefaultWhat it doesWhy this default
IntakeNot governedReads the sentence and drafts the request from the catalogue; never invents a resourceThe requester confirms the draft, so a person is always in the loop
Least-privilege scoperL3Narrows the permission inside the entitlement’s ceilingIt can only remove permissions, never add; a too-narrow grant is cheap to fix
Risk & approvalL3Scores; approves automatically when the flow and score allowBounded by flows and thresholds the organisation wrote; at L1/L2 its approval is a recommendation the approver sees
Session watchL2Flags out-of-scope or sensitive activity; asks security to revokeRevoking interrupts someone mid-incident; a person should confirm first
Standing-access cleanupL1Proposes converting standing admin, escalation paths, unused roles and database superusers to on-requestRemoving standing access changes the estate and can break automation
Access reviewerL3Pre-fills each review line Keep or Remove, with the reasonThe reviewer still decides each line; pre-filling is a suggestion
CopilotRead-onlyAnswers questions such as “who has write on prod right now?” from the recordsIt cannot change anything
quadrantChart title Default autonomy by reversibility and reach x-axis Easy to undo --> Hard to undo y-axis Narrow reach --> Wide reach quadrant-1 Draft only quadrant-2 Act, a person signs off quadrant-3 Act and tell quadrant-4 Ask first Scoper: [0.15, 0.25] Risk and approval: [0.3, 0.35] Access reviewer: [0.25, 0.6] Session watch: [0.65, 0.3] Standing cleanup: [0.85, 0.85]

Illustrative. The further an action is from easy to undo and narrow in reach, the more a person should see it first.

Worked example: session watch at L2

In the demo organisation, Priya, on call for payments during incident INC-4412, received an automatic one-hour grant (AR-0001) to read the payments-api logs on prod-payments. The scoper had narrowed it to six CloudWatch Logs actions on one log-group pattern. During the grant the session made two in-scope log calls, then called secretsmanager:GetSecretValue on prod/payments/stripe-key. AWS denied the call because the scoped policy did not allow it.

Session watch, which compares activity against the grant’s scope and stated reason, flagged the call as sensitive. At L2 it did not revoke. It put a proposal in the agent inbox: revoke AR-0001, with the event that triggered it, for security to approve or reject.

The agent inbox showing a session watch proposal to revoke AR-0001, with the denied secretsmanager event and approve and reject buttons
The agent inbox. Session watch’s proposal: revoke AR-0001. The event, the grant’s scope and the reason are on the card; security approves or rejects.

Why ask first? Because the right answer depends on things the agent cannot see. Perhaps a runbook told Priya to check the key’s rotation date; perhaps Priya’s laptop is compromised. Cutting off an on-call engineer mid-incident has a cost, and a security analyst can weigh it in a minute with a phone call. Notice also what already happened without any agent: the scoped permission meant the secret was never read. Least privilege did the protecting; session watch did the noticing.

An organisation with a mature security operations team might move session watch to L3 for critical resources, so it revokes immediately and tells security, who can re-grant if it was a false alarm. That is a legitimate choice. It is a choice to make deliberately, with the 30-day record in front of you.

sequenceDiagram participant P as Priya participant B as Broker participant AWS as AWS participant W as Session watch participant S as Security P->>AWS: logs:FilterLogEvents (in scope) P->>AWS: secretsmanager:GetSecretValue AWS-->>P: Access denied AWS-->>W: Activity event W->>W: Out of scope and sensitive W->>S: Proposal: revoke AR-0001 (L2) S->>W: Approve or reject W->>B: If approved, a signed revoke instruction B->>AWS: Remove permission set

At L3 the agent would revoke first and tell security, who could re-grant.

Reversible and on the record

Autonomy is only acceptable if mistakes are cheap to find and cheap to undo. Three properties make that true.

Every action has an inbox entry. At L2 it waits there; at L3 it is there with an undo. Approve, reject and undo are the same three buttons for every agent.

Every action is in the audit trail in words. “Agent applied — Least-privilege scoper: AR-0008: narrow to SELECT on billing.invoices (from SELECT on *.*)”, attributed to agent:scoper with a timestamp. Auditors can sample agent decisions exactly as they sample human ones.

Every agent has a track record. The settings page shows runs in the last 30 days, and how many were applied, approved, rejected and reverted. In the demo, the scoper ran on 8 requests and applied all 8; the risk agent ran 4 times and applied 4 automatic approvals. A rising reverted count is the signal to turn an agent down a level.

The backstop does not depend on any agent

Agents run in the control plane. Grants are made by the broker, which the customer runs in their own network. It checks every instruction’s signature, refuses actions on its local never-grant list (by default iam:*, organizations:*, sts:*), enforces its own longest-grant limit, and revokes at expiry on its own clock. An agent set to L4 cannot instruct the broker to do something its local policy refuses.

The read-only Copilot completes the picture. Security can ask, in plain words, “who has write on prod right now?”, “what did Sam do with yesterday’s grant?” or “which standing admins are left?”, and get an answer from the same records the agents used. It cannot change anything, which makes it the safest way to check whether the other agents are behaving as expected.

What stays with a person

Some decisions should not be delegated whatever the dial says, because they need context that no record holds or because accountability must sit with a named individual.

DecisionWhy a person keeps it
Denying with contextAR-0006 was denied by security because exports are frozen during INC-4412. No score knew that.
Approving admin in productionFlow #30 requires two named people (payments.lead and security) plus step-up. The risk agent can recommend, not replace them.
Accepting standing accessKeeping a standing admin needs a written reason someone will answer for.
Final say on access reviewsThe access reviewer pre-fills lines; the named reviewer signs off. An auditor expects a person’s attestation.
Setting ceilings, flows and thresholdsThese express risk appetite. Agents operate inside them.

Honest limits

Agents read the records InsightKeys holds: the catalogue, flows, on-call schedules, incidents, past grants and session events (CloudTrail, database activity, Kubernetes audit). Where those records are incomplete, so is the agent’s judgement. On-call sync from PagerDuty or Opsgenie and ticket validation against Jira or ServiceNow are planned, not available. Session recording for SSH and kubectl is on the roadmap. The scoper can narrow a grant further than the task needs; the remedy is a new request, which is quick but not free.

Setting the dial in your organisation

First 30 days

Watch

  • Agree a deployment ceiling with the CISO (L3 is a sensible start).
  • Run the scoper and risk agent at L2 if you want to see every decision first.
  • Session watch at L2; cleanup at L1.
  • Read the agent inbox daily.
Days 30–60

Trust the bounded agents

  • Move the scoper and risk agent to L3 once rejections are rare and understood.
  • Let the access reviewer pre-fill the first quarterly review.
  • Review reverted actions weekly.
Days 60–90

Decide on the sensitive ones

  • Consider session watch at L3 for critical resources only.
  • Work through cleanup proposals; keep cleanup at L1 until standing admin is near zero.
  • Report each agent’s 30-day record to the security committee.

Do not ask whether agents should decide access. Ask how far each one may act before a person looks, and how you take it back.

Set the dial per agent, cap it with a ceiling, keep every action in an inbox and the audit trail, and let the broker in your network refuse what no agent should ever be able to ask for.

Keep reading