AI Automation Playbook: How to Map, Document, and Automate Your First Processes

By Kirill Stolbushkin

Short answer: An AI automation playbook is a repeatable method for turning how your company works into automated processes that people and AI agents can follow. It runs in eight steps: list processes by team, score them, capture how the work really happens, map and document it, write the rules and exceptions, decide what AI does and where people approve, build and connect agents, then measure and update. The map comes before the automation. Skip it and you automate the confusion.

The AI automation playbook at a glance

The playbook is eight steps, and each step produces one thing you keep.

Some context on me: I'm Kirill, and I cofounded Vevos, whose tagline is "the AI Playbook for how companies run." So yes, I think about this all day. This post is the method; if you want the definition first, read what an AI playbook is and how to build one. You can try step four as you go: paste a process description into vevos.ai/free, no account required.

Copy the table into your project doc and fill in the right column as you go.

SOP vs playbook vs process map

An SOP tells a person how to do one task, a process map shows how work flows between people and systems, and a playbook is the approved set of both that people and agents run on.

You need all three, but the playbook is what an automation can safely follow. Our post on SOPs vs work instructions vs process maps goes into the document types.

Step 1: List the processes in each team

Start with an inventory of recurring work per team, because you can't pick the best first process from a list of one.

Ask each team lead for the ten things their team does every week, a name and one line each. Duplicates and fuzzy names are fine at this stage. To prompt the conversation:

For a longer list, see our 30+ business process examples.

Step 2: Score and pick the first processes

Pick the first processes by volume, how rule-based they are, how much pain they cause, and how cheap a mistake is.

Score each candidate from 1 to 5 on four questions: how often it runs, how much can be written as rules, how much waiting or rework it causes, and how cheap a mistake is to fix (5 means very cheap). Here's a sample shortlist. The scores are illustrative, made up for this example; yours will differ.

Take the top two or three. A frequent, rule-based process with low risk beats an important but messy one. Win there first.

Step 3: Capture how the work really happens

Capture the process from what people actually do, not from the policy binder, because the binder is usually out of date.

Useful sources, roughly in order: a recording or call where someone walks through a real case, the existing SOP even if it's stale, five to ten recent examples with at least two exceptions, and a short interview with whoever handles the hard cases. Write down the workarounds; that's where the real rules live. Our guide on turning a meeting transcript into a process map shows how to use a walkthrough.

Step 4: Map and document the process

Turn what you captured into a process map and written documentation, then have the person who does the work review it.

A map makes gaps visible: the missing approval, the step two teams each think the other owns, the exception with no path. BPMN works well because it's a standard that people can read and software can follow. You can generate a first draft from an SOP and fix it from there; see converting an SOP into a BPMN diagram and how to review an AI-generated process model.

Step 5: Write rules and exceptions an agent can follow

Rewrite every decision as a rule and every exception as a named path, because "use judgment" isn't something an agent can follow.

Three fixes cover most processes. One action per step: "check the vendor and set up payment" becomes two steps. Rules with numbers: "large purchases need approval" becomes "purchases over $5,000 need the department head." Named exceptions: "if the tax ID is missing, send it back to the requester" is a path, not a footnote. Our post on AI-ready SOPs has more examples.

Step 6: Decide what AI does and where people approve

Split each process into steps the AI does alone, steps where it prepares and a person decides, and steps only a person does.

Two controls make this concrete. Authority limits set what the agent may do on its own, such as approving purchases under $250. Approval gates are steps where the agent stops and a named person approves, edits or rejects. Put gates on money above the limit, anything sent outside the company, irreversible actions and exceptions, and start strict.

Three companion guides help here: our human-in-the-loop workflow guide on where gates belong, the approval matrix template for setting limits by amount, and the AI agent governance framework for owners and review.

Step 7: Build the automation and connect your agents

Build on the approved version of the process, so the automation does what the map says and nothing else.

There are two routes, and many teams use both. You can build an app around the process, such as a request form, an approval screen and a status view; see from process map to working app. Or you can let AI agents follow the approved playbook directly, with its gates and limits. Before either goes live, add the agent to your register as described in the governance framework, and test the gates on real past cases.

Step 8: Measure ROI and update the playbook

Measure one or two numbers you chose before you started, calculate ROI with a simple formula, and update the playbook when the work changes.

Good numbers to track: time from request to done, items that wait for a person, rework rate, and how often people override the agent. Measure the same way before and after. For ROI, use this formula and plug in your own figures:

• Annual benefit = hours saved per run × runs per year × loaded hourly cost, plus the yearly cost of errors and rework you avoid.

• Annual cost = software and running costs per year, plus the hours spent reviewing, approving and maintaining the playbook, plus one-time setup spread over the first year.

• ROI = (annual benefit minus annual cost) divided by annual cost.

Our guide on how to calculate the ROI of business process automation goes deeper. When the process changes, update it, review the diff and sign off on the new version, then pick the next candidate.

The 30/60/90-day rollout

A 30/60/90-day rollout gets the first process live in a month and makes the method repeatable by month three.

The timings are a plan, not a promise. Exceptions and approvals take the most time, so budget for reviews.

Worked example: new vendor setup

Here's the playbook on one process at an illustrative 120-person company (not a customer): setting up a new vendor so the business can pay them.

1. List and score. Procurement named vendor setup in its top ten. It scored high on pain because requests stalled for days.

2. Capture. The procurement lead recorded a walkthrough of two recent setups, one with a missing tax form.

3. Map. The walkthrough became a BPMN map: request, document check, tax form check, restricted-list check, approval, setup, confirmation. The lead fixed two steps in review.

4. Rules. "Check the vendor is OK" became three rules: tax form present, contract signed, no match on the restricted list.

5. Gates and limits. The agent may check documents and request missing items. A gate sends every new vendor to the procurement lead before setup, because payment details are involved. A second gate sends vendors with expected spend over $50,000 to the finance manager.

6. Build and connect. A request form and approval screen were built from the map, and the team's agent followed the approved version for the checks.

7. Measure. The team tracked days from request to setup and how often requests came back incomplete.

The numbers will be yours. The point is that each step produced something the next one used.

Common mistakes

The most common mistake is automating a process nobody has written down; the rest are close behind.

• Automating before mapping. You automate today's confusion, faster.

• Starting with the hardest process. Pick a frequent, rule-based one first.

• Rules without numbers. "Large" and "urgent" mean different things to different people and nothing to an agent.

• No owner. Every process and every agent needs one named person.

• Gates everywhere. People stop reading, and the gates stop protecting you.

• No measurement before launch. Without a baseline, you can't show a result.

• Never updating the playbook. The work changes; the version agents follow must change with it.

Running the playbook in Vevos

In Vevos, steps 3 to 8 happen on one playbook, from the captured process to the version agents follow.

The free mapper covers step 4 with no account. Everything else is on the pricing page.

FAQ

Short answers to the questions people ask about AI automation playbooks.

What's the difference between an AI playbook and an AI automation playbook?

An AI playbook is the record of how your processes work: steps, owners, rules and exceptions. An AI automation playbook is the method for building that record and automating from it, step by step. Our post on what an AI playbook is covers the first.

What's the difference between a playbook and an SOP?

An SOP is written steps for one task, for a person. A playbook is the approved process behind many tasks: the map, the documentation, the rules, the owners and the limits, versioned so people and agents follow the same thing.

How do you calculate the ROI of AI automation?

Take the annual benefit (hours saved per run times runs per year times loaded hourly cost, plus error and rework costs avoided), subtract the annual cost (software, review time, upkeep and setup), and divide by the annual cost. Use your own baseline numbers measured before launch.

What's an example of an AI automation playbook?

New vendor setup: capture a recorded walkthrough, map it in BPMN, turn checks into rules, let the agent collect and check documents, gate every new vendor before payment setup, build a request form, and track days to setup.

Which process should I automate first with AI?

A frequent, rule-based process where mistakes are cheap to fix and the waiting is painful. Invoice matching, ticket triage and access requests are common first picks.

Related reading

These guides cover the control side of the playbook.

• AI agent governance framework with an agent register and metrics

• Human-in-the-loop workflow examples and approval gate design

• Approval matrix template with thresholds by process

• What AI business process automation is and where it fits

Try the playbook on one process

The quickest way to start is to run steps 1 to 4 on a single process this week.

Describe it at vevos.ai/free and get a BPMN map and documentation draft. When you want to set gates, build and connect agents, see plans and pricing.