Skip to content
Back to blog
Autonomy5 min read

AI agent autonomy is a permission per action, not an on/off switch

Autonomy for an AI agent is granted per action: read, prepare, execute, escalate. Permissions, limits and audit are the product, not a setting buried in a menu.

By lapersona team

The demo that sells an on/off switch

There's a comfortable way to sell AI agents and a dangerous way to buy them: the one that presents them as a switch. "Turn on autonomy and the system works by itself." It sounds good in a demo. In a real revenue operation, the first question a manager asks is the right one: what can it do without me?

The useful answer isn't "everything" and isn't "nothing". It's a list of actions with different permissions. Autonomy isn't granted to the system once. It's granted per action. That distinction, switch versus permission per action, decides whether a team can adopt AI without losing control of what it says, sends, spends or changes.

Why on/off is the wrong model

When autonomy is a switch, the team has two positions. Off, and the agent is useless. On, and nobody knows exactly what's going to happen. In practice you pick one of two things: leave it off and abandon it, or switch it on and hope.

The problem is that actions aren't equivalent. Reading an account's history isn't the same as emailing a customer. Preparing a brief isn't the same as publishing it. Changing an internal note isn't the same as closing an opportunity or committing to a discount. Putting all of it under one permission forces a choice between paralysis and risk.

Useful autonomy is granular because the work is granular.

Four decisions per action: read, prepare, execute, escalate

A system that executes sales work makes four kinds of decision. Each one can carry a different permission.

  1. Read. What data it can access: the CRM, email, LinkedIn, Slack, the data warehouse. Reading is the base of everything else, and it's also a privacy decision: not every account and every thread should always be available.
  2. Prepare. What it can build without anything leaving the building: a brief, a draft, a proposed next step, a value case. Preparing is where the system adds the most value with the least risk, because a human still sees the output before it exists in the world.
  3. Execute. What it can do in the world: send a message, create a task, update a field, launch a sequence. This is where autonomy starts to have consequences, and where prior approval stops being a brake and becomes the design.
  4. Escalate. When it has to stop and ask for help: a strategic account, an amount above a threshold, an objection it can't handle, a request outside the playbook. A system that can't escalate isn't autonomous. It's unpredictable.

The recommended sequence is the one a new rep follows: read first, then prepare, then execute with review, and once judgement shows, more autonomy. You don't start at the end.

How to give an AI agent autonomy without losing control

Decide permission by permission: what it can read, what it can prepare, what it can execute and what it must escalate to a person. Sensitive or irreversible actions require prior approval. Permissions, limits, escalation rules and audit are configured per team.

Human approval wherever the action is irreversible

The rule that orders everything else is simple: if the action can't be undone, a person approves it. Emailing a prospect can't be undone. Publishing a piece can't be undone. Spending budget on a campaign can't be undone. Closing an opportunity or changing a record another team depends on can't be fully undone either.

In lapersona, sensitive or irreversible actions require prior approval. Every action lands in the inbox with its why and its context. The rep approves, corrects or rejects. And it's logged who approved what. That traceability isn't a compliance ornament. It's what lets the team answer for what the system does.

Human approval doesn't turn the agent into a passive assistant. It removes the part it shouldn't decide alone and leaves the part it can execute: research, draft, organise, prepare, remind and measure.

Limits, permissions and audit: what a team must be able to configure

If autonomy is a permission per action, the configuration has to be visible and editable. A team should be able to define, at minimum:

  • Permissions by role. Who can read what, who can approve what, and who can change the permissions.
  • Limits. How many actions per day, how many contacts per account, which amounts or discounts need review.
  • Escalation rules. Which situations stop the play and who gets notified.
  • Untouchable accounts. Which strategic or sensitive accounts stay out of automated execution.
  • Audit. What was done, with what context, who approved it and what came of it.

The difference between a product and a buried setting is right here. These controls have to be part of the product, not a tab nobody finds. If the team can't explain in a meeting what the system does and who answers for it, they aren't ready to give it autonomy.

Memory is a design decision too

An agent that learns stores something: approved and rejected plays, replies, meetings and outcomes. That memory is what makes it improve. It's also what raises the awkward questions: what's stored, for how long, who can see it, and how it gets corrected.

Memory shouldn't be a black box. It should be reviewable, revertible and exportable. And it should separate what the system learned from a human decision from what it inferred on its own. The traceability of the approval is also the traceability of the learning.

Start by letting it read and prepare

Sensible adoption doesn't start by granting permission to send. It starts by granting permission to read and prepare, with a person reviewing every output. When the team confirms the context is good and the proposals save time, execution with approval gets added. When execution shows judgement, the limits widen.

That path isn't slower. It's the only one that gets you far without having to switch the system off halfway.

The CRM stores. The tools assist. lapersona executes with the permissions you configure. Autonomy is a decision per action.

See how it works → https://lapersona.ai/en#how

Create account → https://app.lapersona.ai/register

Next step

Want to see it on your CRM?

Tell us how your team works and we will show you what lapersona would execute in the first conversation.

Create account

Book a demo

Let's talk.

Leave your email and we'll write to you to find a time.

By sending, you accept our privacy policy.