The Four Levels of AI Autonomy: Observer, Advisor, Drafter, Executor

If someone could do everything for you, would you still hand them the keys to your house and your social security number? Probably not. No matter how useful something is, we ought to look into what it can do and how it can access things. The adage goes: trust but verify. This could not be truer today in the AI world, where you want some sort of control over all the delegation in this new normal. But AI autonomy is the question everyone skips past when they’re busy getting excited about agents. You get one working, you wire it up to your systems through MCP and click “all” on any permissions, you hand it the right skills, and somewhere in that excitement the actual question gets lost: how much is this thing allowed to do without me in the room, and what does it have access to? Note that everyone and all systems define their own autonomy levels, and it is somewhat open to interpretation, but the gist of it all falls into four rungs on a ladder: Observer, Advisor, Drafter, Executor. They sit from doing nothing on their own to doing everything on their own, and where any given task lands on that ladder is not something the model decides. It’s you who can and should control it.

If you’ve been following this series since post 1, you already know what an agent, a skill, an MCP connection, and a harness are. Autonomy levels are the control layer that sits on top of all of that architecture. If the concepts are the what, the autonomy levels are the how.

The four levels

The four levels run from least to most autonomous:

• Observer: watches and reports. Informational only, no human action required.
• Advisor: suggests actions. The human decides and acts.
• Drafter: does the work and submits it for approval. The human approves or sends it back.
• Executor: acts autonomously. The human reviews after the fact.

Observer

Remember the CRC agent from post 1, the one watching the SFTP server for new data drops? That’s Observer level. The agent monitors, surfaces what it sees, and stops there. It doesn’t tell you what to do about a missing data point. It merely tells you there’s a missing data point. It’s a reporter. This is the right level for anything where you want visibility without committing to action yet. It’s also a good way to test the waters.

Advisor

Advisor goes one step further. The agent isn’t just watching anymore; it’s forming an opinion. Think of it as a second opinion you didn’t ask for but got anyway: the agent runs its analysis and says, here’s what I’d do. You read it, you decide whether you agree, and you’re the one who acts. This is also called Assist in some interpretations, but the phrasing doesn’t matter much.

Drafter

This is where most regulated pharma workflows actually want to live, at least at first. A Drafter agent does the real work, not a suggestion, actual work, and then it stops before that work becomes consequential. It writes the memo, runs the check, produces the structured table, or generates the findings, and holds all of it in a review queue. A human approves it or sends it back. The output is real. It just doesn’t count for anything until a person says it does. That approval step is the gate, and in a regulated environment, it’s usually the most useful gate you have: the agent handles production, the human handles judgment. You save time, but you do not skimp on control or validation.

Executor

Executor is the only level where the agent acts first and tells you second. The action is already done by the time you see it. Your job is review, not approval. That’s fine when the task is low-stakes, easily reversible, or when you’ve watched the agent handle enough edge cases over time that you actually trust it with a narrowly scoped job. It is not fine for anything consequential or irreversible in a regulated context until you have real evidence, not a hunch, that the agent handles the edge cases correctly.

You set the level

This is the part people get wrong, over and over. Autonomy levels aren’t something the model figures out for you as it goes. They’re configuration choices you make when you design the workflow, step by step. The same model can sit at Advisor for a data extraction task and run at Drafter for a formatting task in the same pipeline, because those two tasks carry completely different consequences if something goes sideways.

How to choose the right level

The rule is simple: the more irreversible the action, the lower the autonomy level. Or phrased another way, the more reproducible an action, the higher the autonomy level. Ask two questions about each step in your workflow:

If the agent gets this wrong, what does it cost to fix? And can it be undone without data loss, compliance exposure, or downstream errors?

If the answers are “a lot” and “not easily,” stay at Drafter or lower. If the answers are “not much” and “yes,” Executor is probably fine. Start lower than you think you need to; think of it like a haircut: you can always cut more hair, but you can never make it grow instantly. You can always expand autonomy once you have evidence the agent handles a given step reliably, again and again, not just once. You cannot as easily walk back a mistake made at full autonomy in a regulated context.

A pharma example: CDISC validation

Take a CDISC validation step in a clinical data workflow. The agent runs the validation checks against your dataset, identifies issues, and drafts a findings report with the specific violations, affected variables, and recommended corrections. That step runs at Drafter. The agent produces real, usable output. The data manager reviews the findings, confirms the analysis holds up, and approves the report before any corrective action happens. Miss something or flag a false positive, and the data manager catches it and sends it back, the same way they would if a junior CRC had drafted it.

What this means for your workflows

You don’t deploy an AI assistant. You deploy a set of workflow steps, each with its own assigned autonomy level based on what that specific step is allowed to do. Some steps watch, some suggest, and some take the task all the way to completion. The goal is the right level for each step, set by what’s actually at stake if that step goes wrong. We plan to solve autonomy levels and agent orchestration with our attempt at Mediforce, which combines not just autonomy levels but ideas and concepts much more relevant to the pharma context.