The seven decisions behind putting an agent into a real workflow

Last month our invoicing agent closed Whitesmith’s month-end. It pulled the billables, matched them to the work that actually happened, checked the intragroup line that never quite reconciles, drafted the invoices, verified its own drafts, and staged everything in one review sheet. I opened that sheet, checked the exceptions, and signed off, because the agent handles the assembly work, but the decision to send, and the accountability for it, stay with me (the person who owns the process).

This agentic workflow started with seven decisions, written down before we built anything. The same seven sit behind every agent we run, and behind the ones we build with clients. Independently of the model or tool you want to use, these decisions are the actual work.

Here they are, each tied back to something the invoicing agent taught us.

1. Objective

State the business outcome in one sentence. For invoicing, it was: close month-end with every line reconciled before anything goes out. A vague ambition like “use AI in finance” won’t do, because a real objective names the result and lets you tell later whether you got it.

The test is whether a sceptical finance lead would recognise the outcome as theirs. If the sentence could describe any company, it is too vague to design against.

2. Owner

Name the human who stays accountable. The agent executes, but a person owns the process and answers for it when the agent flags something odd.

This is one of the two decisions teams skip, and skipping it is expensive. No owner means no one is accountable when a call needs to be made, and the workflow quietly rots. The owner is whoever’s job depends on the outcome being right, which is usually not the person who built the agent.

3. Source of truth

Decide which data the agent is allowed to trust. For invoicing, that was our billables sheet, the time tracking, the intragroup accounts, and the invoicing system, and nothing else. The agent reasons from those sources and never invents a number or relies on its own memory of who paid.

Getting this right is usually where the difficulty lies, and it is where our first close tripped. The agent reconciled confidently off a billables figure that was out of date: the reasoning was sound, the input was stale, and the review gate is the only reason the error never reached a client. We fixed it by correcting the source data, and the agent itself never needed changing. If your billables live in five places that disagree, cleaning that up is step zero, before any agent.

4. Trigger

Decide what starts the run. Triggers come in three shapes:

1. Goal-based: the run has a defined finish, like our invoicing agent, which fires at month-end and works until the close is done;

2. Event-based: the agent watches for something to arrive, like our sales agent, which acts when a lead lands in the inbox;

3. Continuous: the agent keeps scanning a source and starts work when a condition is met, like a contract crossing 90 days from expiry.

Name the trigger you actually have today, even if it is “someone remembers.” You can design a better one, but you have to start from the real one.

5. Autonomy contract

Write down what the agent can do and, more importantly, what it cannot. We spent more time on this than on anything else. Our invoicing agent can pull data, reconcile, draft, flag, and log its reasoning. It cannot issue or send an invoice; anything above a set amount or anything it is unsure about waits for a person.

Autonomy works by degree. Some actions stay behind the gate permanently because the downside is too high, and others widen as the agent earns trust. The contract is where you make those choices deliberately instead of by accident.

6. Review gate

Decide where the human enters. This is the part that makes the whole thing safe, so protect it. For invoicing, the gate is a dashboard we built easily. Every run shows up there live, and for each invoice you can see the agent’s proposed action (proceed or hold), the reasoning behind it, and a confidence level, with the reason called out for anything it wants to hold. One place to watch the run, approve, correct, or hold.

Under deadline pressure, the gate is the first thing teams want to skip. It is also the thing that means an agent cannot ship a mistake, so keep it.

7. Metrics

Decide how you will know the workflow improved anything. This is the second decision teams skip, and it kills good workflows in the next budget conversation. Without a number, “it feels faster” is all you have.

For invoicing, the honest metric was where the time goes at month-end: from assembling the close to reviewing exceptions. To put a number on it, we went from half a day of work -  confirming data, reviewing exceptions, reconciling information, updating the different spreadsheets and creating and verifying invoices to an hour of work. Measure the before and the after. Time recovered, error rate, cycle time, whatever maps to the objective you set in decision one.

The blueprint applied: contract renewals

On our webinar ‘How to run business operations with agents’, we also share a live example of a different process: supplier contract renewals.

Usually this process works like this. Contracts sit on a shared drive with their expiry dates and owners. Someone notices a renewal is coming, or worse, a supplier sends a letter announcing a 50% increase. Whoever catches it scrambles to find the contract, the SLA, and the history, then negotiates under time pressure just to avoid a gap in service. The trigger is human memory, which is unreliable, so renewals lapse, and prices drift up.

Run it through the blueprint, and it changes shape.

1. Objective: zero unmanaged auto-renewals. Every renewal is consciously approved, and preparation starts 90 days out.
2. Owner: the operations or procurement director, who decides and stays accountable while the agent prepares.
3. Source of truth: the contract repository, the SLA records in your ERP, and the extracted terms from each agreement. The agent trusts the documents, never an email that claims something.
4. Trigger: continuous. The agent tracks the contract index and starts a renewal process the moment any contract is 90 days from expiry.
5. Autonomy contract: it can index contracts, extract the terms that matter, compile a renewal brief with a recommendation, draft a negotiation position, and flag anomalies that look like legal or business risk. It cannot renew, terminate, or sign anything. A good heuristic: the agent never makes a definitive decision or takes an irreversible action.
6. Review gate: when a renewal triggers, the accountable person gets a brief 90 days out with a clear status and recommendation, and decides to renew, renegotiate, or walk away.
7. Metrics: lapsed auto-renewals (target zero), days before expiry that negotiation starts (earlier is better), and price variance across renewals.

Same seven questions, a completely different function. That is the point of the blueprint: the answers change entirely with each process, while the seven questions you have to answer stay the same.

Where to start

Pick one process that is repeated often, clearly owned, and measurable. Ask which steps are real judgment and which are just a person moving information between systems. The judgment stays with the human, while the information-moving steps are what the agent can prepare.

Then write the seven decisions down before you touch a tool. Once these seven answers exist on paper, and your sources of truth are clean enough to trust, the process can be handed to an agent in days.

If you want to run the blueprint against one of your own processes, that is what we can do in a 90-minute diagnostic. You leave with the seven decisions written down for one process and an honest go or no-go on whether it is ready for an agent.