tech-ai
Who Signs Off When an Agent Approves a Refund? Designing Review Points
A customer asks for a refund. An agent reads the request, checks the order history, applies the policy, and issues the payment. Nobody typed anything. The ledger is updated, the customer is notified, and the case is closed. Then, three weeks later, finance asks a simple question: who approved this? If the honest answer is "the system", the process has a governance gap, whatever its technical quality. Designing review points is the discipline of making sure that question always has a precise, defensible answer.
This article is about that discipline. It does not argue for more human checks or fewer. It argues for placing them deliberately, based on the nature of each step in a process, and for redesigning the process around agents rather than bolting an agent onto a workflow built for people.
Why the refund is a good test case
Refunds look routine, which is exactly why they are instructive. They combine several properties that appear in most business processes where agents are considered:
- A policy that is mostly clear but has edge cases. Most requests fit a rule; a minority require interpretation.
- A financial effect that is real and sometimes hard to reverse. Money leaves the company, and recovering it is slower than sending it.
- Several systems involved. Order management, payment, customer relationship tools, accounting.
- A customer on the other end. Errors in either direction, wrongful refusal or wrongful approval, have consequences.
- An audit trail expectation. Someone, at some point, will want to reconstruct the decision.
If you can design sound review points for a refund, you have a pattern you can reuse for credit notes, supplier payment releases, contract amendments, access requests, and many other approvals.
Start by decomposing the process, not by choosing the tool
The usual mistake is to ask "can an agent handle refunds?" The question is too coarse. A refund process is a chain of distinct steps, and an agent's suitability differs from one step to the next.
Take a generic refund flow and break it down:
- Receive and classify the request.
- Gather the facts: order, delivery status, prior contacts, product condition.
- Check eligibility against policy.
- Decide: approve, refuse, partially approve, escalate.
- Execute: trigger the payment or credit.
- Communicate the outcome to the customer.
- Record, reconcile and learn.
An agent may be well suited to steps 1, 2 and 6, acceptable under conditions for 3 and 4, and the question of who is accountable concentrates on steps 4 and 5. Review points are not sprinkled evenly across this chain. They belong where a decision is made or where an irreversible action is taken.
Separate three kinds of work
It helps to label each step as one of three types:
- Preparation: collecting, reading, summarizing, drafting. Errors here are usually caught later and cost little.
- Decision: applying judgment to choose an outcome. Errors here propagate.
- Commitment: taking an action that changes the state of the world, such as paying, sending, or deleting. Errors here may be difficult to undo.
Agents are generally a strong fit for preparation, a conditional fit for decision, and the most carefully constrained for commitment. A reviewer is most valuable at the boundary between decision and commitment: the moment before the effect becomes real.
Levels of autonomy: a working vocabulary
Before placing review points, the organization needs shared language for how much latitude an agent has. The following scale is a practical simplification, not a standard, and you should adapt the labels to your own context.
| Level | Agent role | Human role | Typical use |
|---|---|---|---|
| 0. Assist | Suggests, drafts, retrieves | Decides and executes | Early pilots, high-stakes or novel cases |
| 1. Propose | Recommends a decision with its reasoning | Approves or overrides each case | Cases with material financial or legal effect |
| 2. Act with sampling | Decides and executes within limits | Reviews a sample and all exceptions | Well-understood, bounded, reversible cases |
| 3. Act with monitoring | Decides and executes within limits | Monitors indicators, intervenes on alerts | Mature, low-risk, easily reversible steps |
Two points matter here. First, autonomy is a property of a step, not of an agent. The same agent may propose at one step and act at another. Second, the level is not permanent. It should move up or down based on evidence from evaluation, which is covered below.
Designing the review point itself
A review point is not simply "a person looks at it". Poorly designed review points fail in predictable ways: reviewers approve everything because volume is high, they lack the context to disagree, or they are asked to validate a conclusion without seeing the reasoning behind it. A well-designed review point has five elements.
1. A clear trigger
Define in advance what routes a case to a person. Triggers fall into a few families:
- Threshold-based: the amount, the customer segment, or the product category exceeds a defined limit.
- Confidence-based: the agent signals that the case is ambiguous or outside what it has handled reliably.
- Pattern-based: the request resembles a known abuse pattern, or the customer's history shows unusual activity.
- Policy-based: the case touches a rule that always requires a named approver, regardless of the agent's confidence.
- Random: a share of otherwise automatic cases is drawn for review, so that quality is measured and not assumed.
The last one is easy to forget and important. If only flagged cases reach a human, nobody sees the cases the agent got wrong without noticing.
2. A named role, not a vague function
"Customer service" does not sign off. A role does, held by identifiable people with a defined delegation of authority. The delegation matrix that already exists for human approvers is the right starting point: if a team leader may approve refunds up to a certain level, the agent's authority should be derived from, and bounded by, that same structure rather than invented separately.
This is the answer to the title question. When an agent approves a refund, the accountable party is whoever granted the agent that scope of authority and whoever owns the process. The sign-off moves upstream: from approving each case to approving the rules, limits and monitoring under which the agent operates. That is a legitimate form of control, but only if it is explicit and recorded.
3. A decision package, not a raw case
The reviewer should receive what they need to decide in a short time:
- the request and the relevant facts retrieved,
- the policy clauses the agent applied,
- the recommended outcome and the reasoning in plain language,
- the alternatives considered,
- the points of uncertainty,
- what happens if the reviewer approves, and what if they refuse.
If the reviewer must re-do the investigation, the review point has erased the benefit of the agent. If the reviewer sees only a conclusion, they are rubber-stamping.
4. The right to disagree, with a feedback path
When a reviewer overrides the agent, that override is information. Capture the reason in a structured way where possible. Overrides are the raw material for improving instructions, adjusting thresholds, and deciding whether a step can move to a higher level of autonomy.
5. A time and capacity budget
Review points that are never staffed become bottlenecks, and bottlenecks create pressure to bypass them. Size the review workload realistically before go-live, and decide what happens when it is exceeded: queue, escalate, or reduce the agent's scope. A review point that exists on paper but is routinely skipped is worse than none, because it creates a false record of control.
Orchestrating agents with people and existing systems
The refund does not live inside the agent. It lives across systems that already carry rules, permissions and logs. Good design uses that fact.
Let existing systems keep their authority
The payment system should enforce limits independently of the agent. If the agent is instructed not to refund above a threshold but the system would allow it, the control rests on the agent following instructions. If the system refuses the transaction, the control is structural. Prefer controls that hold even if the agent misbehaves.
In practice this means:
- giving the agent its own identity and credentials, distinct from any employee,
- granting the minimum permissions needed for the specific steps it performs,
- keeping write access narrow, and read access scoped to what the task requires,
- separating the ability to propose a payment from the ability to release it.
That last separation mirrors a classic segregation-of-duties principle. The agent that decides should not be the only party able to execute without an independent check, at least until evidence supports relaxing it.
Define the hand-offs explicitly
In a process with several agents and several people, hand-offs are where information and accountability leak. For each hand-off, specify what is passed, in what format, who owns the case at that moment, and what happens if the receiving party does not respond. A case should never sit in an ambiguous state where neither the agent nor a person owns it.
Plan for failure
Decide in advance what the agent does when a system is unavailable, when data is inconsistent, or when it receives an instruction it cannot satisfy. The default should be to stop and escalate, not to improvise. An agent that continues confidently on bad data is more dangerous than one that halts.
Redesign the process, do not automate it as is
Many existing processes contain steps that exist only because humans were the executors: re-keying data between systems, approvals added to compensate for low visibility, queues organized around working hours. Placing an agent in the middle of such a process preserves its accidental complexity.
Redesigning around agents means asking different questions:
- Which approvals exist because information was scarce? If the agent can assemble the full picture in seconds, a multi-level approval chain may be reducible to a single review on the cases that warrant it.
- Which checks should move earlier? Eligibility can be assessed at the moment of the request, not after several exchanges.
- Which exceptions are really design flaws? If a large category of cases is always escalated, the policy may need clarification rather than the agent more freedom.
- What can now be done that was previously impractical? Reviewing every case for abuse patterns, or explaining each decision in a consistent format, may become feasible.
A useful exercise is to map the process as it runs today, mark the steps that are preparation, decision and commitment, and then redraw it by asking what the minimal set of human judgments would be if information were available instantly. The result often differs substantially from the original flow.
Evaluation: the evidence that justifies each level of autonomy
The level of autonomy granted to a step should be supported by evidence, and that evidence should keep being produced.
Before go-live
Build a set of representative cases, including difficult and adversarial ones, with outcomes agreed by experienced staff. Run the agent against it and examine not only whether it reached the right outcome but whether the reasoning was sound. Include cases designed to test the boundaries: ambiguous policy, missing data, customers pressing for exceptions, attempts to manipulate the agent through the content of a request.
In operation
Track indicators that reveal drift and misuse. Useful categories include:
- the rate at which reviewers agree with or override the agent,
- the distribution of cases across autonomy levels,
- complaints and reversals linked to agent decisions,
- patterns of requests that seem designed to exploit the process,
- the time reviewers spend per case, which signals whether review is substantive.
Define in advance what result triggers a reduction in autonomy, and who has the authority to make that call. A level of autonomy that can only go up is not governed.
After changes
A new model version, a modified instruction, a policy update or a new integration can each alter behavior. Treat these as changes requiring re-evaluation, with the same discipline applied to any change in a controlled process.
Security considerations specific to agents
Agents introduce risks beyond those of conventional automation, largely because they interpret natural language and can be influenced by what they read.
- Untrusted content as instruction. A customer message, an attached document, or a web page may contain text intended to redirect the agent. Treat all external content as data, never as authority, and keep the agent's instructions and permissions independent of what it reads.
- Excessive permissions. The more the agent can do, the more an error or manipulation can cost. Narrow scope is a security measure as much as a governance one.
- Data exposure. Define what personal and commercial data the agent may see, retain and transmit, consistent with data protection obligations such as GDPR where applicable.
- Traceability. Log what the agent received, what it retrieved, what it decided, which rules it cited, and what it executed, in a form that can be reviewed later and protected from alteration.
- Third-party dependencies. Where models or tools are supplied externally, understand what data leaves your environment and under what terms.
Frameworks such as the NIST AI Risk Management Framework and ISO/IEC 42001 offer structured vocabularies for these risks and for management systems around them. They are useful as checklists and common language, though they do not replace process-specific analysis.
Governance and regulatory context
Governance of agents does not need to begin from nothing. Most organizations already have delegation of authority, segregation of duties, change control, audit and incident management. The task is to extend these to a new kind of actor.
A workable governance minimum includes:
- An owner for each agent-supported process, accountable for outcomes.
- A register of agents in operation, with their scope, permissions, autonomy levels and review points.
- A defined approval path for introducing or expanding an agent's authority.
- An incident procedure covering wrong decisions, suspected manipulation and system failure, including how affected customers are made whole.
- A periodic review of whether each level of autonomy is still justified.
On the regulatory side, the EU AI Act introduces obligations that depend on how a system is classified and used, including expectations around human oversight, transparency and record-keeping for certain categories. Whether a given refund process falls into a regulated category depends on its context, and that determination should be made with legal advice rather than assumed. Where decisions affect individuals, data protection rules on automated decision-making may also apply.
Even where no specific obligation applies, the principle behind these texts is a good design guide: meaningful human oversight means a person with the competence, authority and information to intervene, not a formal signature.
A generic illustration
Consider a services firm that handles billing disputes. Customers contest an invoice line; an agent reads the contract, the usage records and the previous correspondence, and proposes a credit.
In a first phase, the agent only prepares: it assembles the file and drafts a recommendation, and a finance analyst decides every case. The firm measures how often the analyst agrees and why they override.
In a second phase, for small credits tied to a clearly defined contractual clause, the agent issues the credit directly, while the billing system itself caps the amount. A sample of these cases is reviewed each period, and every case involving a key account goes to a named account manager regardless of amount.
In a third phase, the firm examines the overrides and the sample results. It tightens an ambiguous clause in the policy, extends the agent's scope to one more category, and removes an approval step that had never changed an outcome. A rule remains: any new category begins again at the proposal level.
Nothing in this sequence relies on trusting the agent in the abstract. Each step in autonomy is earned by evidence and bounded by controls that sit outside the agent.
Common failure patterns
- Approval theater. Reviewers approve in bulk because volume is high and context is thin. The record shows control; the reality does not.
- Autonomy by default. The agent is given broad permissions because narrowing them takes effort.
- Review only on flagged cases. Without sampling, errors that the agent does not detect stay invisible.
- No owner. The agent belongs to IT, the process to operations, and the risk to nobody.
- Static design. Levels of autonomy set at launch and never revisited.
- Automating the old process. Legacy approvals and workarounds preserved around a new component.
Practical next steps and questions to ask
If you are considering placing an agent in a process that involves approvals, the following sequence is a reasonable place to start:
- Pick one bounded process with a clear policy, reversible or limited effects, and a measurable volume.
- Decompose it into preparation, decision and commitment steps, and note who is accountable for each today.
- Assign a starting autonomy level per step, beginning conservatively at the decision and commitment steps.
- Write the review triggers and the named roles, derived from your existing delegation of authority.
- Move hard limits into the systems, so that key controls do not depend on the agent following instructions.
- Build the evaluation set and the monitoring indicators before go-live, including the rule for reducing autonomy.
- Name the process owner and record the agent in a register.
Questions worth asking in your next steering meeting:
- If this agent approves a payment today, can we say precisely who is accountable, and is that written down?
- Which of our existing approvals exist only because information used to be scarce?
- What would make us reduce this agent's autonomy, and who would decide?
- Do our reviewers have the context and the time to disagree?
- Which controls would still hold if the agent behaved incorrectly?
- How would we reconstruct a single decision six months from now?
The aim is not to slow agents down or to trust them blindly. It is to ensure that when an agent approves a refund, the organization can say, calmly and precisely, who authorized that authority, under what limits, and on what evidence.
Going further with Stratelya
Stratelya Orchestra is built around this problem: defining which steps an agent may handle, where a person must sign off, and how those review points are traced and evaluated across existing systems. It gives operations leaders a structured way to place human judgment where it matters rather than everywhere or nowhere.
Explore Stratelya Orchestra, or book a 30-minute diagnostic call.
Stay informed
Get notified when we publish new insights on strategy, AI, and execution.
Unsubscribe at any time. Privacy policy
Related Insights
tech-ai
Securing the Agentic Enterprise: Governance Architecture for AI Agent Deployment
AI agents are not tools—they are active actors that perceive, decide, and execute autonomously. The security frameworks enterprises have built for passive softw…
tech-ai
The Agentic Layer: How Multi-Agent Orchestration Is Reshaping Enterprise Operations
AI systems are no longer merely tools that humans use — they are becoming agents that reason, plan, delegate, and execute across extended sequences of actions. …
tech-ai
AI-Accelerated Product Development: The New Velocity War in Enterprise Competition
Artificial intelligence is compressing product development timelines by an order of magnitude in some domains. This analysis examines what is genuinely changing…