Use normal automation when structured input leads to a stable, testable rule. Use bounded AI when a variable input needs interpretation but the allowed output can be constrained and checked. Consider a tool-using agent only when the task genuinely requires choosing among tools or steps, and keep its permissions narrow. Keep consequential, ambiguous, or hard-to-reverse decisions human-owned unless an approved control system can reliably contain the risk.
The question is not whether AI can produce an answer. The question is whether adding probabilistic interpretation makes the whole process safer, clearer, or more useful after validation, monitoring, fallback, and review costs are included.
This framework starts after a business has chosen a process worth improving. The automation-priority scorecard answers which process to consider first. This article answers how each step in that process should execute.
Separate four execution modes
Do not label an entire process “AI” or “automation.” Classify each decision and action.
| Mode | What it does | Best fit | Main control |
|---|---|---|---|
| Deterministic automation | Follows explicit conditions and actions | Structured inputs, stable rules, exact outputs | Rules, validation, idempotency, logs |
| Bounded AI assistance | Interprets variable content into a constrained output | Classification, extraction, summarization, drafting | Schema, allowed labels, unknown path, review |
| Tool-using AI agent | Chooses among approved tools or steps to pursue a goal | Variable multi-step work where fixed routing is impractical | Least privilege, approvals, budgets, tracing, recovery |
| Human-owned decision | A person evaluates context and accepts responsibility | Sensitive, novel, disputed, consequential, or hard-to-reverse work | Authority, evidence, documented decision and appeal |
A workflow can combine all four. A form can be validated deterministically, an AI step can propose a category, a person can approve a sensitive exception, and normal automation can update the approved record.
Use the rules-vs-AI decision framework
Evaluate one step at a time.
| Decision | If yes | If no |
|---|---|---|
| Is the required input already structured and complete? | Prefer rules. | Continue. |
| Can the correct decision be expressed as stable conditions? | Prefer rules, even if AI could imitate them. | Continue. |
| Is the output limited to a small schema or approved set of labels? | Consider bounded AI with validation. | Continue. |
| Can an “unknown” result stop safely for review? | Bounded AI may be testable. | Keep the step human-owned. |
| Does the step need to select and call tools? | Consider an agent only if fixed orchestration is not enough. | Do not add agent autonomy. |
| Can every tool be restricted to necessary records and actions? | Add explicit approvals for consequential actions. | Do not give the agent the tool. |
| Is a wrong action easy to detect and reverse? | A controlled pilot may be possible. | Require human approval or manual ownership. |
| Can the business evaluate quality on representative cases? | Test before release and after changes. | Do not automate the decision yet. |
| Does AI add enough value to justify provider, review, monitoring, and failure costs? | Compare a bounded design with the rules baseline. | Use rules or people. |
This is a design framework, not a scoring benchmark. A single failed safety condition can decide the architecture even if the other answers favor AI.
Choose deterministic automation for stable facts and rules
Normal automation is often the better design when the event, input, and rule are already known. It is easier to replay, audit, and test because the same valid input should follow the same path.
Hypothetical example: route a complete service request
A web form has required fields for service type and postcode. The business has a current table mapping supported postcode ranges to one service queue and a named fallback owner.
The workflow can:
- reject or quarantine submissions that fail field validation;
- normalize the postcode into an approved format;
- look up the service and coverage rule;
- find or update the correct contact using an approved identity rule;
- create one reviewable request record with an idempotency key;
- assign the mapped queue or the fallback owner;
- record the rule version and result.
AI adds no useful interpretation to that step. It would introduce another failure mode without removing a hard rule.
Use rules when the business needs exact eligibility, amount, recipient, state transition, or stop behavior. If the rule changes often, make it configurable and versioned rather than asking a model to infer the current policy from prose.
Use bounded AI for constrained interpretation
AI can help when the input is unstructured but the next system needs a small, verifiable output. The safe unit is usually one interpretation step, not the whole process.
Hypothetical example: classify an inbound request
A customer sends a free-text inquiry. The business wants to propose one of four routing labels:
- new project;
- support for existing work;
- billing question;
- unknown.
The AI step receives only the text needed for classification and returns a schema containing label, reason, and needs_human_review. The application then applies deterministic controls:
- reject any output outside the four labels;
- force
unknownwhen required context is missing; - route billing, unknown, conflicting, or human-review-flagged cases to a person;
- prohibit the AI output from sending a message, changing a balance, or closing a record;
- log the input reference, model version, output, validation result, and final human correction where permitted.
OpenAI’s current Structured Outputs documentation says a supported JSON Schema can constrain non-refusal output to required fields and enum values. It also says applications must still handle refusals, incomplete responses, API errors, and business rules the schema cannot express. A valid shape is not proof that the classification is correct.
Bounded AI should have an unknown path. If the system forces every input into a confident label, it hides uncertainty instead of controlling it.
Keep consequential approval with an authorized person
Some steps should remain human-owned even when AI can prepare the evidence.
Hypothetical example: unusual refund request
AI may extract the order number, summarize the customer’s explanation, list missing documents, and compare the request with an approved policy. Deterministic checks may verify order status and the maximum amount an employee can approve.
The final decision remains with an authorized person when the policy is incomplete, the customer disputes material facts, the amount exceeds a delegated limit, or the action is difficult to reverse. The system records the evidence presented, the policy version, the decision maker, and the final outcome.
This is not “AI with a human in the loop” merely as a slogan. The approval must happen before the consequential tool call, show the person the exact proposed action and basis, and prevent execution if approval is absent or times out.
NIST’s AI Risk Management Framework Core calls for defined use scope, documented human oversight, risk controls for third-party components, monitoring, incident response, recovery, and change management. These controls should be designed for the actual consequence, not added as a disclaimer after launch.
Use tool-using agents only when fixed orchestration is insufficient
An agent can select among tools, gather context, and choose the next step. That flexibility may help with variable research or support tasks. It also creates new risks because untrusted content can influence tool selection and tool arguments.
Before an agent receives a tool, define:
- the exact goal and stopping condition;
- allowed records, fields, systems, and time window;
- read and write permissions separately;
- actions that always require approval;
- budget, step, and retry limits;
- what happens when a tool, model, or dependency is unavailable;
- the trace and business record needed for review;
- a manual recovery route.
Do not give an agent broad access because a future scenario might need it. OpenAI’s current agent safety guidance recommends keeping tool approvals on, treating untrusted data as a prompt-injection risk, constraining data passed between steps, and using guardrails and evaluations. Its guardrail and approval guidance says ambiguous or high-risk actions should pause for explicit human approval before a tool runs.
An unrestricted agent should not be the default for CRM changes, external messages, account permissions, payments, deletions, production configuration, or other consequential writes.
Treat prompt injection as a system risk
Prompt injection happens when untrusted content attempts to influence an AI system’s instructions or actions. It can arrive through a form, email, webpage, attachment, retrieved document, tool output, or another system.
A prompt that says “ignore the policy” is only the obvious case. More subtle content can ask the model to reveal data, choose the wrong tool, or change the target of an action.
Controls include:
- separate instructions from untrusted data;
- pass only the minimum content needed for the step;
- extract constrained fields before later actions;
- validate tool arguments outside the model;
- apply least privilege and record-level scope;
- require approval for external or irreversible effects;
- block secrets from model context and logs;
- test adversarial and malformed inputs;
- fail closed when a control or reviewer is unavailable.
OpenAI’s prompt-injection overview says the risk is not eliminated by model safeguards and recommends limited access and careful review before important actions. Prompt wording alone is not a security boundary.
Design for model failure and provider outages
An AI step can time out, refuse, produce incomplete output, follow the schema but get the meaning wrong, or change behavior after a model or prompt update. A provider or integration can also be unavailable.
For every AI-assisted step, define:
- maximum attempts and timeout;
- whether retries are safe and duplicate-proof;
- a deterministic validation layer;
- the unknown or failed state;
- the person or queue that receives exceptions;
- whether the rest of the process can continue safely;
- the recovery procedure after service returns;
- the change that requires re-evaluation.
Do not let an AI failure look like a valid business completion. A CRM record should distinguish classified, needs_review, and classification_failed if those states lead to different responsibilities.
Compare operating cost and risk, not only model price
Provider token or request price is only one cost. Use a workload-specific comparison.
| Cost or risk | Rules | Bounded AI | Tool-using agent | Human-owned |
|---|---|---|---|---|
| Build | Rule design, integration, tests | Prompt, schema, validation, evaluation | Tools, permissions, orchestration, approvals, evaluation | Procedure, training, queue design |
| Run | Hosting and connector use | Model calls, retries, validation | Multiple model and tool calls, traces, approvals | Staff time and queue delay |
| Change | Rule and regression update | Prompt or model re-evaluation | Tool, policy, prompt, model, and orchestration re-evaluation | Procedure and training update |
| Failure | Wrong or missed rule path | Misclassification, refusal, incomplete result | Wrong plan or tool action, injection, partial execution | Inconsistent judgment or missed work |
| Control | Versioned rules and logs | Schema, unknown path, review | Least privilege, budgets, approvals, traces | Authority, review, escalation |
| Recovery | Retry or compensate | Reclassify or human review | Reconcile side effects and resume safely | Rework or appeal |
Measure the complete path: volume, average and worst-case input size, retries, tool calls, validation, exception rate, human review time, monitoring, incident response, and provider drift. Do not claim savings until the actual process has comparable evidence.
AI adds no real value when a lookup table or conditional rule already produces the correct result, the input is already structured, the output cannot be validated, the volume is too low to justify controls, or staff must fully redo every output before use.
Evaluate the design before and after release
Build a representative test set that includes normal cases, edge cases, missing information, conflicting information, malicious instructions, out-of-scope requests, and provider failures. Write the expected outcome before running the system.
Acceptance criteria should cover:
- task result: correct allowed output or correct escalation;
- validation: schema and business rules pass;
- safety: no unauthorized tool or data access;
- state: one clear record of pending, approved, failed, or complete;
- duplicate handling: retries do not repeat side effects;
- review: consequential actions cannot bypass approval;
- failure: outages produce a visible recoverable state;
- observability: logs identify model, prompt or workflow version, tool calls, validations, and final outcome without unnecessary personal data;
- maintainability: a model, prompt, rule, tool, or policy change triggers the affected tests.
OpenAI’s current agent evaluation guide describes traces, graders, datasets, and repeatable evaluation runs for finding regressions in model and tool behavior. The product can help collect evidence, but the business still defines what counts as correct and safe.
Acceptance-testing checklist
Architecture
- Each step is classified as rules, bounded AI, agent, or human-owned
- AI is used only where interpretation adds value
- Deterministic validation surrounds AI output
- An explicit unknown and failure path exists
- Consequential decisions have an authorized approval gate
Permissions and security
- Data is minimized for the task
- Read and write scopes are separated
- Tool targets and arguments are validated outside the model
- Secrets are excluded from prompts, client code, and routine logs
- Untrusted inputs and prompt injection are in the test set
Reliability and recovery
- Retries are bounded and duplicate-safe
- Outages and refusals create visible exception states
- Partial tool actions can be reconciled
- A manual path exists
- Owners and response responsibilities are documented
Evidence
- Expected results are written before tests
- Representative normal and exception cases pass
- Model, prompt, schema, rule, and tool versions are recorded
- Human corrections are available for evaluation where privacy permits
- Release, rollback, and monitoring criteria are approved
Choose the simplest architecture that meets the process need
Normal automation is not the old option and AI is not automatically the advanced option. A rule is better when the rule is known. Bounded AI is useful when interpretation is necessary and checkable. An agent is justified only when adaptive tool choice adds value that fixed orchestration cannot provide within the required controls. A person should retain decisions whose consequence, ambiguity, or authority demands judgment.
If you need help mapping those boundaries across forms, CRM, calendars, approvals, and other tools, Business Process Automation and AI Integration is the relevant Edex Growth service. The first deliverable should be a process and control design, not a promise to add AI everywhere.
Sources and editorial scope
Technical guidance was checked on November 15, 2026 against NIST’s AI RMF Core and current OpenAI documentation for Structured Outputs, agent safety, approvals, prompt injection, tracing, and evaluations. Product capabilities and interfaces can change. The decision framework, examples, cost comparison, and acceptance checklist are original editorial tools. The examples are hypothetical, not client results, legal advice, security certification, model-accuracy claims, or ROI forecasts.
