Why an agent needs a “review” button
Consider a routine support workflow. An employee opens a ticket, checks the customer history in the CRM, consults a policy, drafts a reply, and changes the ticket status. A language model can read the context, find a relevant instruction, and prepare a draft. But if it is also allowed to send emails, promise compensation, and change records, an error in one step can become an external business outcome.
A useful first version for a small or midsize business is not an “unrestricted digital employee.” It is an executor with a narrow set of tools: read permitted data, prepare a proposal, wait for approval when the cost of error is material, and perform only the specific action that was approved.
This is not a property of one model. It is a boundary between probabilistic decision preparation and deterministic execution in a CRM, email, accounting system, or order service.
Classify actions by their consequences
Before development, divide operations into three groups.
- **Suitable for direct automation in a pilot:** classify a ticket, extract an order number, produce a summary, draft a reply, suggest a category, or assign a task under a fixed rule. These steps must not send a message or independently change money or access rights.
- **Require explicit human review:** send an external email, promise a deadline or discount, change an owner in a way that affects an SLA, issue a refund or write-off, publish content, or close a case with legal significance.
- **Do not expose as agent tools:** arbitrary SQL, bulk deletion, permission changes, money transfers, and any operation that company policy reserves for a separate process or dual control.
This is not a universal legal classification. The appropriate control depends on consequences, reversibility, and the authority model already in place. An internal draft can be recreated; a promise already sent to a customer is much harder to undo.
A practical pattern: propose, review, execute
Build the workflow as explicit states rather than one long prompt.
1. **Receive the task and context.** The integration layer checks the user’s permissions and fetches only the CRM fields that are needed. If the agent must consult policies, add RAG so it receives relevant excerpts with a source and document date, not the entire corporate archive.
2. **Prepare a structured proposal.** The model returns fields such as `action`, `customer_id`, `draft_text`, `reason`, `source_ids`, and required parameters. Free-form text must not become a CRM command directly.
3. **Validate the proposal with ordinary code.** Check the schema, customer identity, permitted fields, discount limit, ticket status, and whether the source record is still current. An unknown action or failed condition means rejection or clarification.
4. **Pause for review.** The person sees exactly what will happen, to whom, based on which data, and what will change. They can approve, edit, or reject it.
5. **Recheck after approval.** The server verifies that the reviewer is authenticated and authorized for that action. It then rechecks business rules: the record may have changed while the proposal was waiting.
6. **Execute a narrow command.** Prefer separate operations such as `save_reply_draft`, `send_approved_reply`, and `set_ticket_category` over a universal `update_record(any JSON)`. The executor receives minimal permissions and only parameters from the approved version.
7. **Record the outcome and recover safely.** Store the ticket ID, reviewer, snapshot of the approved parameters, CRM result, and timestamp. On failure, do not blindly repeat the action: use an idempotency key, inspect the previous attempt, or request a manual reconciliation.
The OpenAI Agents SDK documentation describes a similar cycle: a sensitive tool call can pause a run, wait for a decision, and resume with saved state. LangGraph provides `interrupt` and checkpointing for pausing, saving state, and continuing after an external response. These are implementation options, not required stack choices.
What an approval card should show
The review screen is part of the control, not a ceremonial button. If the employee only sees “The agent requests permission,” it is difficult to spot an error.
Show:
- the customer and record that will be changed;
- the message text or exact field changes;
- a brief explanation of why the agent proposed it;
- the sources it used and the policy version date;
- consequences such as an external send, refund amount, SLA change, or status transition;
- the proposal’s expiry time and a warning if the underlying data changed after preparation.
Approval must apply to one action and its exact parameters. If the model can change the text, amount, or recipient after approval, that is no longer the same approved action. A material edit should send it back for review.
A minimum architecture for a small team
A pilot can often start with four components: a CRM connector, an orchestrator with a model and a limited tool set, storage for pending approvals, and a small approval panel or bot. Add a search index if the agent needs company policies; use a local model or protected environment for the relevant processing when data requirements call for it.
“Local model” and “action control” solve different problems. Running a model inside the company may reduce external data transfer, but it does not by itself limit the model’s CRM permissions. Conversely, a cloud model can prepare a draft without being able to send it, if tools and server-side authorization are properly separated.
Use a separate technical account with minimum permissions to access business systems. Enforce authorization in the integration service and the target system; do not ask the model to decide who is allowed to do what. OWASP recommends limiting agent-extension functionality and permissions, validating requests in downstream systems, logging activity, and applying rate limits.
Where RAG fits—and what it cannot do
RAG helps when an agent needs current instructions: refund rules, service descriptions, delivery windows, or escalation criteria. Preserve the source, version, and effective date for every excerpt. If documents conflict, do not let the model choose whichever answer sounds convenient; route the conflict to an employee.
Retrieval from a knowledge base does not replace system checks. A customer email or attachment can contain instructions intended to manipulate the agent. Treat that text as content to analyze, not as authority. Even a policy excerpt that permits a discount must be checked by code against the current user role, limit, and order state.
Fine-tuning is usually not the first step. Start by checking data quality, retrieval from current documents, output structure, and straightforward rules around tools. If an answer cannot be verified against a source or required field, the action should stop.
Risks and protection against duplicate actions
Pausing before a tool call reduces risk, but it does not automatically provide complete security. Add separate server-side controls:
- a short-lived approval identifier bound to the reviewer, object, and exact parameters;
- a fresh permission check at execution time, not only when the card is displayed;
- protection against double-clicks and repeated event delivery;
- an expiry time after which the proposal must be generated again;
- an audit log without unnecessary personal data and a quick way to disable the tool;
- action limits and a safe fallback if the model, CRM, or approval interface is unavailable.
If approval demands too much attention, employees may start clicking “approve” by habit. Automate low-risk, reversible steps and reserve manual review for actions with external or financial consequences. Audit a sample of automatically executed operations and review rejection reasons.
How to evaluate a pilot without promising “X times savings”
Do not begin with an invented automation percentage. Choose one ticket type and establish a short baseline: time from arrival to first response, employee handling time, share of drafts edited, category error rate, and repeat-contact rate. Then compare the same workflow with the agent.
Track separately:
- minutes spent reviewing and approving;
- proposals employees change or reject;
- cases where data became stale while awaiting approval;
- operations that had to be reversed or corrected;
- model, integration, and support cost per handled ticket.
The economic effect is not only the time saved by the agent. If preparation gets faster but the approval queue grows, the bottleneck has moved. If speed is unchanged but missing fields and repeated manual searches decrease, the result may still be valuable—measure it as process quality.
A first implementation plan
- Choose one process with clear existing rules and a measurable outcome.
- Start with read access and draft preparation, without write permissions.
- Build a test set from anonymized or otherwise permitted examples, including conflicting and incomplete requests.
- Add a narrow tool for approved actions and server-side authorization checks.
- Run a limited pilot on part of the workflow while keeping the current process as a fallback.
- After an agreed period, decide whether to expand autonomy, change the rules, or keep the agent as a preparation assistant.
The management takeaway
Do not start by asking, “Can the model answer customers on its own?” Define which actions it may only propose, which ones an employee must approve, and where approval does not replace a separate control. Then give the agent one small part of the workflow with a measurable outcome and an audit trail.
