Plan, Act, Check: Putting AI Agents to Work Without Losing Control
Agents can take real work off people’s plates. They can also take real actions nobody intended. The answer isn’t to keep them in a box. It’s to design them the way you would any other critical system.

On this page 9 sections
From answering questions to doing things
For most enterprises, the first wave of generative AI was about answers. Summarise this document. Find the relevant policy. Draft a reply. Useful, and relatively safe, because a person read the output before anything happened.
The next wave is different. Agents don’t just answer; they act. They raise a purchase order, update a customer record, reschedule a delivery, file a ticket, send the email. That is where a lot of the value is, because so much enterprise work is the tedious chain of small actions between “we know what needs doing” and “it’s done”.
It is also where the risk is. An assistant that gives a wrong answer wastes a few minutes of someone’s time. An agent that takes a wrong action can cost real money, break a promise to a customer, or create a compliance problem that takes weeks to unwind.
That difference should shape everything about how agents are built. Not with fear, but with the same discipline we already apply to payment systems, trading platforms and anything else where mistakes are expensive.
A small example to keep in mind
Let’s make it concrete. Picture an operations team at a manufacturer. A carrier updates its tracking feed: an inbound shipment of a critical component will be 36 hours late.
Today, a planner notices this, maybe. They check stock levels at the affected sites, look up the supplier contract to see what the service levels say, work out whether any customer orders are at risk, phone a colleague about moving stock from another warehouse, draft a note to the customer service team, and get approval from their manager for the extra transport cost. It takes a couple of hours if everything goes smoothly, and it competes with twenty other things in their day.
An agent system can do most of that legwork in minutes and hand the planner a clear recommendation with the evidence attached. But only if it is designed so that the planner, and the business, stay firmly in control. The rest of this article is about how.
One planner, several narrow specialists
The tempting design is one big, clever agent with access to everything. Give it the tools, give it the goal, let it figure things out.
We avoid that. Instead, we use a planner that breaks the goal into steps, and a small number of specialist agents, each with a narrow job:
- A retriever that finds the relevant contract terms, supplier history and policies, and cites where each fact came from.
- An analyst that runs the numbers: stock levels, forecast demand, the cost of each option.
- An actor that prepares changes in enterprise systems, such as a transfer order or a customer notice, but doesn’t send them on its own.
Narrow agents are easier to test, because you know exactly what each one is supposed to do. They are easier to secure, because each gets only the tools and data it needs. And they are easier to explain, which matters enormously when an auditor, a regulator or simply a curious manager asks, “Why did it do that?”
If one specialist misbehaves, the damage is contained, and the planner can retry, choose a different route, or stop and ask for help.
A reviewer step isn’t a sign that you distrust the agent. It is simply how important work gets done.
Control lives in the tools
Agents act through tools. So the tools, not the prompts, are where real control lives.
A prompt can say “never spend more than ten thousand without approval.” A well-designed tool simply won’t let it. We think about tools the way a good platform team thinks about any internal API:
- Typed interfaces. Every tool has a clear contract: what goes in, what comes out, what errors look like. No free-text commands to production systems.
- Least privilege. The tool runs with only the permissions it needs, under an identity you can trace.
- Hard limits. Caps on spend, on the number of records it can change, on which environments it can touch.
- Draft first. Wherever possible, actions are prepared as drafts and executed only after checks pass.
That last point deserves emphasis. A draft purchase order can be reviewed, edited or thrown away. A sent one has to be recalled, explained and, sometimes, apologised for.
A reviewer before anything leaves
Before anything leaves the system, a reviewer checks it. In our shipment example, that means asking: does the proposed transfer order have every required field? Is it within the planner’s authority? Is the reasoning backed by the evidence the retriever found, or did something get invented along the way? Does the customer notice say anything we are not allowed to promise?
Some of these checks are simple rules. Some are evaluations by another model, tuned specifically to spot problems. All of them are logged, so you can see later exactly what was checked and why something passed or failed.
If this sounds like extra overhead, it’s worth remembering that it is exactly what good organisations already do with people. Code gets reviewed. Payments above a threshold need a second signature. Contracts go past legal. A reviewer step isn’t a sign that you distrust the agent. It is simply how important work gets done.
People approve what matters
Not every step needs a person. Pulling a contract clause or calculating stock cover doesn’t need sign-off. But anything consequential should pause for approval: spending above a threshold, changing a commitment to a customer, touching regulated data, or doing anything that is hard to reverse.
The design of that approval step matters more than people expect. If approvals are slow, opaque or too frequent, people start rubber-stamping them, and you have the worst of both worlds: the illusion of control without the reality.
So we make approvals informative and fast. The approver sees what the agent wants to do, the evidence behind it, the options it considered and why it rejected them, and what happens next if they say yes. Approving or rejecting is a single, informed decision, not a puzzle.
- Can the approver understand the request in under a minute?
- Do they see the evidence, not just the conclusion?
- Is it clear what happens if they say no?
- Are we asking for approval often enough to matter, but rarely enough to be taken seriously?
The foundations nobody demos
Underneath every agent system sit three shared layers that rarely appear in demos but decide whether the system survives contact with reality.
Memory and knowledge. Agents need working memory for each task, so they don’t lose track halfway through, and access to the organisation’s knowledge, with permissions respected.Guardrails and identity. Every call should know who it is acting on behalf of. Single sign-on, role-based access, redaction of personal data and spend limits should apply automatically, not be reimplemented in each agent.Observability and evaluation. Every plan, tool call, cost and outcome should be recorded. Not just for compliance, but because it is the only way to improve the system over time. You can’t fix what you can’t see.Build these once, properly, and each new agent becomes a much smaller, safer project. Skip them, and every agent turns into its own security review and its own audit headache.
Five ways agent projects go wrong
Most agent failures we see are not exotic. They are ordinary engineering and design mistakes, made more expensive because the system can act.
- Too much autonomy, too soon. The agent is allowed to execute before anyone has seen how it behaves on real cases.
- Tools that are too powerful. One “do anything in the ERP” tool instead of a few narrow ones with limits.
- No memory of what happened. When something goes wrong, nobody can reconstruct the plan, the evidence or the tool calls.
- Approval fatigue. Every small step needs sign-off, so people stop reading and start clicking.
- Costs nobody watched. Long reasoning loops and repeated retries quietly multiply the bill, and finance notices before engineering does.
Each one is avoidable with the patterns above. None of them is avoided by a better prompt.
Where to start
If you are considering agents, resist the urge to start with the most ambitious use case. Pick a workflow that is frequent, well understood, and currently slowed down by people gathering information from several systems before they can act.
Start with the agent doing the preparation and a person doing the deciding. Measure the time saved, the error rate and how often people accept the recommendation. As the evidence builds, widen the agent’s autonomy one step at a time: perhaps it can execute low-value actions automatically, while anything above a threshold still pauses.
That gradual approach can feel slow. In practice it is usually the fastest route to agents that do real work, because it builds the one thing no technology can shortcut: the trust of the people who have to live with the results.
Key takeaways
- Use a planner and narrow specialist agents, not one agent with access to everything.
- Put control in the tools: typed, least-privilege, limited, draft first.
- Review every output against rules, policy and evidence before it leaves.
- Make human approvals fast and informative, and reserve them for what matters.
- Build memory, guardrails and observability once, for every agent.
Case studies & examples
References & further reading
- Building effective agentsAnthropic, 2024
- OWASP Top 10 for LLM ApplicationsOWASP GenAI Security Project
- Model Context ProtocolOpen specification
- Generative AI Profile (NIST AI 600-1)NIST, 2024
Links checked on 1 November 2026. External sources are listed for further reading; Delphilens is not affiliated with them.