You have a workflow everyone agrees is wasteful. Customer feedback is copied between systems. The same context is gathered for every follow-up. Reports are assembled by hand. The tempting response is to put an AI agent on the whole process and ask it to take over.
That is usually too much autonomy, too early. Your first decision is not which model or automation platform to buy. It is where the workflow needs fixed rules, where it needs judgment, and where a person must remain accountable. Get those boundaries right and you can build something that saves work without creating an invisible queue of errors.
Automate the rules; assign only bounded judgment to an agent
The practical distinction is behavioral: automation follows a predefined process, while an AI agent can work toward a goal and decide what to do next. Automation is a good fit when the next action can be expressed as a stable rule. An agent becomes useful when the input varies, the path cannot be fully enumerated, and the result can still be checked.
An agent is not an upgraded version of every automation. It is a bounded decision-maker inside a larger system. The larger system should still handle triggers, permissions, data validation, retries, approvals, records, and monitoring with explicit logic wherever possible.
| Work pattern | Best default | Why | Example |
|---|---|---|---|
| The inputs, rules, and next action are stable | Deterministic automation | There is no useful judgment to delegate | Copy an approved form submission into a spreadsheet and send a standard confirmation |
| The input is unstructured, but the output is bounded and reviewable | Agent inside a workflow | Interpretation helps, while the surrounding process can remain controlled | Classify customer feedback, extract themes, and draft a structured summary |
| The correct action depends on consequential context | Human decision with AI preparation | A wrong action could create customer, financial, legal, security, or reputational harm | Prepare the facts for a refund, contract exception, or security escalation without authorizing the decision |
| The task has no observable definition of success | Redesign before automating | Neither a person nor an agent can be evaluated against a vague outcome | “Improve customer experience” without a specific workflow, recipient, or result |
Use three questions to place each step:
- Can the correct next action be written as a rule? Use ordinary automation. A model adds variability without adding value.
- Does the step require interpreting language, comparing incomplete information, or choosing among permitted paths? Consider an agent, but give it a narrow goal and a checkable output.
- Can a wrong action cause material harm or an external commitment? Keep approval with a person until the system has both strong evidence and appropriate controls. Some decisions should remain human regardless of model quality.
This classification prevents a common architecture mistake: asking the model to manage the entire process because one step requires judgment. If only feedback classification is ambiguous, the agent should classify feedback. It does not also need authority to edit account records, email customers, change ownership, and close tickets.
Design the minimum useful workflow around one observable outcome
Start with a unit of work, not a general ambition. “Handle customer feedback” is too broad. “Turn each new feedback item into a reviewed theme, concise summary, and assigned owner” is observable. You can inspect whether the workflow finished, whether the fields are usable, and where it failed.
A useful workflow definition fits this pattern: When [trigger] occurs, produce [observable result] for [recipient], unless [named exception] requires review. If you cannot complete that sentence precisely, the workflow is not ready for an agent.
- Name the trigger. Identify the exact event that starts a run: a submitted form, a new ticket, an uploaded document, a scheduled review, or an approved request. Avoid triggers such as “when needed” because no system can reliably detect them.
- List the required inputs. Separate information available at the trigger from information the workflow must retrieve. Mark any data the agent is not allowed to access. A missing input should produce an exception, not a guess.
- Write the current steps in sequence. Include the small actions people forget to mention: checking identity, removing duplicates, looking up account context, applying a naming convention, and notifying the next owner.
- Classify every step. Label it deterministic, judgment-based, or human-controlled. This exposes where an agent is actually needed and where a workflow engine is enough.
- Define the agent’s contract. Give it a goal, permitted information, allowed tools, required output fields, prohibited actions, and a clear stopping condition. “Research this company” is open-ended. “Return its website, stated product category, and a draft outreach note, or mark the record unresolved” is bounded.
- Define the exception path. Decide what happens when information is missing, two records conflict, a tool is unavailable, or the agent cannot reach a supported conclusion. Route the case to a named queue with the reason and relevant context attached.
- Place review before consequence. Review should happen before an email is sent, a record is overwritten, a payment-related action is taken, content is published, or a commitment is made. Reviewing an audit log after the damage is not an approval mechanism.
Consider a customer-feedback workflow. A new item is the trigger. Deterministic steps validate the customer identifier, collect account context, and check for duplicates. An agent interprets the unstructured message, assigns one of the permitted themes, summarizes the issue, and drafts a response. Explicit rules route security, billing, and contractual matters to a person. After approval, automation writes the structured fields to the system of record and notifies the owner.
That hybrid design uses judgment where it helps while keeping execution predictable. It is also easier to debug. If the wrong theme appears, inspect the agent step. If the owner is not notified, inspect the deterministic delivery step. When one agent owns everything, diagnosis becomes a replay of an opaque conversation.
Choose implementation tools only after drawing this workflow. Visual platforms such as n8n, Make, and Zapier can connect applications and automate processes, while the OpenAI Agents SDK is aimed at developers building tool-using, multi-step agents. The relevant question is not which tool has the longest feature list. It is whether the tool can express your trigger, permissions, approval gate, exception path, and audit needs without turning a simple process into custom infrastructure.
Give the agent a small blast radius and an obvious way to stop
Autonomy is a permission design problem. Telling an agent to “be careful” is not a control. A production workflow needs boundaries that still hold when the model misreads an instruction, receives incomplete context, or encounters a tool failure.
- Use the narrowest data access that completes the task. If the agent only needs contact name, company, and ticket history, do not expose unrelated account data or an unrestricted document store.
- Allowlist tools and actions. Give the agent specific operations such as read ticket, search approved knowledge, create draft, or submit for review. Do not provide a general-purpose write tool when a narrow operation will do.
- Validate structured output outside the model. Required fields, permitted categories, identifier formats, and allowed destinations should be checked by code before the next step runs.
- Separate drafting from sending. Creating a response and delivering it are different permissions. The same separation applies to recommending a record change versus writing it.
- Set explicit stop conditions. Missing required data, conflicting records, an unavailable tool, an unsupported request, or an out-of-scope category should end the autonomous path and create an exception.
- Make repeated actions safe. Give each run and consequential action a unique identifier. Before a retry sends, writes, charges, publishes, or creates anything, check whether that action already succeeded.
- Keep a usable run record. Capture the trigger, retrieved inputs, tool calls, model output, validation results, approval decision, final action, and failure reason. Redact or restrict sensitive data rather than logging it indiscriminately.
- Provide a manual fallback. A person should be able to see what happened, correct the result, resume or close the case, and prevent the same run from acting again.
A simple autonomy ladder helps product leaders resist the jump from prototype to unsupervised execution:
- Observe: the agent reads permitted information and produces an internal analysis.
- Draft: it prepares content or structured changes, but a person must apply them.
- Recommend: it proposes a next action and shows the evidence needed for a decision.
- Act within reversible internal boundaries: it performs a validated action that can be inspected and undone, while exceptions still go to a person.
- Act externally or irreversibly: it sends, publishes, pays, deletes, grants access, or makes a commitment. These actions require the strongest controls and often should retain human approval.
Move a workflow up this ladder one capability at a time. Do not grant send, edit, and delete permissions together merely because the draft output looks good. Each permission creates a different failure mode and needs its own evidence.
The human review experience matters as much as the agent. A reviewer should receive the proposed action, supporting context, uncertainty or conflict, and a clear set of choices. If reviewers must reconstruct the entire case, the workflow has moved data gathering rather than eliminated it. If approvals are routinely accepted without inspection, the gate exists only on paper.
Measure accepted outcomes, exceptions, and human effort
A polished demo proves that the happy path can work. It does not prove that the workflow creates value. Before launch, collect representative examples from the real process, including incomplete inputs, duplicates, conflicting information, ambiguous requests, and known edge cases. Write the evaluation criteria before inspecting the agent’s answers so the rubric does not drift to excuse the output.
Measure the existing process first. Otherwise, faster-looking automation can hide rework, longer exception queues, or extra review effort. Track metrics by workflow version and by case type rather than relying on one blended success score.
- Completion rate: the share of triggered runs that reach the defined end state without manual reconstruction.
- Accepted-output rate: the share of results accepted under the prewritten rubric. Record edits separately so “approved after a rewrite” is not counted as clean success.
- Exception rate: the share routed to a person, grouped by reason. A high exception rate may indicate poor inputs or an overbroad scope rather than a weak model.
- Human effort per completed case: include review, correction, investigation, and recovery time. An agent that runs quickly but requires extensive checking has not removed the bottleneck.
- End-to-end completion time: measure from trigger to accepted outcome, including time waiting in approval and exception queues.
- Cost per accepted outcome: include model use, workflow infrastructure, human review, and rework. Cost per agent run is misleading when many runs fail or need correction.
- Control failures: track attempted out-of-scope actions, validation failures, duplicate-action prevention, approval bypass attempts, and cases where the run record is incomplete.
- Business outcome: connect the workflow to the result it exists to improve, such as usable research records, response preparation time, correctly routed feedback, or resolved requests. The right outcome depends on the workflow.
Launch in stages. First, run the workflow in shadow mode and compare its output with normal work without changing production records. Next, let it draft for review. Then permit a narrow set of reversible actions. Expand scope only when representative cases meet the agreed quality bar, failures are visible, duplicate actions are prevented, rollback works, and the exception queue has a named owner.
Do not advance because a pilot has been running for a certain number of days. Advance because the evidence supports the next permission. The acceptable bar should rise with the consequence of error: an internal draft and an external commitment should not share the same release criteria.
Every production workflow also needs an operating owner. Someone must own the business outcome, review metric changes, inspect recurring exceptions, approve scope expansion, and pause the system when controls fail. Without that ownership, an agent does not eliminate operational work; it relocates the work into a queue nobody manages.
Key takeaways: six questions before you launch
- Is the outcome observable? Can you tell, case by case, whether the workflow produced a usable result?
- Which steps are truly ambiguous? Keep stable rules in deterministic automation and confine the agent to judgment that adds value.
- Is the agent’s contract bounded? Specify its inputs, tools, output schema, prohibited actions, and stopping conditions.
- Does permission match risk? Separate read, draft, recommend, write, send, publish, pay, and delete authority instead of treating autonomy as one switch.
- Can failure be seen and recovered? Validate outputs, record runs, prevent duplicate actions, route exceptions, and make consequential changes reversible where possible.
- What evidence unlocks more autonomy? Agree on quality, human-effort, outcome, and control criteria before expanding the workflow’s scope.
Choose one repetitive workflow this week and map its trigger, steps, judgment points, consequences, and exceptions. Automate the stable path first. Add one bounded agent step only where interpretation is the actual constraint. That smaller system will teach you more about production agent design than a broad autonomous-assistant prototype ever could.
References








