Service 03
Digital staff that take the action.
Agentic AI Design
Agentic AI is software that pursues a goal rather than following a script: it decides its own next step, uses tools to act on real systems, and continues until the task is done or it needs a human. We design agents with scoped tools, explicit guardrails, approval gates you set, and logging designed so you can reconstruct what the agent did.
What an AI agent actually is
A workflow follows a path you drew; an agent works out the path itself.
Strip away the marketing and an AI agent is four things: a goal, a set of tools it is permitted to use, the judgement to decide which tool to reach for next, and a condition that tells it when to stop. The model supplies the judgement. Everything else is engineering, and the engineering is what decides whether the result is trustworthy.
That is why 'we use AI agents' tells you almost nothing about a system. The questions that matter are which tools it can touch, what it is allowed to do without asking, what happens when it is unsure, and whether you can see what it did. Those answers are the design.
- Tools
- The specific, scoped actions an agent can take: read this mailbox, query this table, draft this record. Not general system access.
- Memory
- What the agent carries between steps and between runs, and, just as importantly, what it is required to forget.
- Guardrails
- The rules it cannot cross: spend limits, data it may not read, actions requiring sign-off, topics it must escalate.
- Evals
- A test suite of real cases with known-good outcomes, run whenever the agent or the model behind it changes.
- Orchestration
- The coordinator that splits a job across specialist agents, manages hand-offs and assembles the result.
Autonomy is a dial, and you set it
The debate about whether AI should act autonomously is a false binary. Autonomy is a setting, chosen per action, on evidence.
Suggest only
The agent does the work and proposes the result. A person reviews and executes. This is where almost every agent starts, and where some stay permanently, which is a perfectly good place for one to end up.
Act with approval
The agent completes the task fully and holds it at a gate. The human decision shrinks from 'do this work' to 'yes or no', which is where the time comes back.
Act within bounds
The agent proceeds unsupervised inside limits you define (under a dollar threshold, within a policy, on a document type with a proven accuracy record) and escalates anything outside them.
You stay in control
Each agent runs at the level you choose, and the level can differ per action within one agent. Drafting a reply might run unsupervised while issuing a credit note stops at a gate. We design so that what it did, why, and who approved it can be reconstructed afterwards, and we agree during design how much detail that needs to capture.
The sensible progression is to start at suggest-only, watch the evaluation results and the exception queue for a few weeks, and move the dial on the actions where the evidence supports it. That is how trust gets built: on a record, not on a promise.
Agentic teams: specialists, not one big brain
A single agent asked to do everything degrades in a predictable way. Its instructions grow, its context fills with irrelevance, and its behaviour becomes harder to reason about with every capability added.
So we structure agentic work the way a business structures a function: an orchestrator that takes the request, splits it and tracks it to done, and specialists with narrow remits and narrow tool permissions. A research agent that can read but not write. A drafting agent that produces text but touches no systems. A quality agent whose only job is to check the others' work against your rules. A human gate before anything leaves the building.
The structure is not decorative. Narrow scope makes each agent more accurate, cheaper to run and far easier to audit, and when something does go wrong, it localises the fault to one specialist instead of one enormous prompt.
How we design and build an agent
- Define the job precisely: what 'done' means, what is explicitly out of scope, and what must never happen
- Scope the tools: the minimum set of actions required, each with its own permission
- Write the guardrails with your team, including the escalation conditions
- Build the evaluation set from real historical cases with known-good outcomes
- Build the agent, then run it against the evaluation set until the results hold
- Deploy at suggest-only, with structured logging on every step
- Review the logs and the exception queue with you, then move the autonomy dial where the evidence supports it
Step four is the one that separates a production agent from a demo. Without an evaluation set you have no way to know whether a change to the prompt, a new model version or a shift in your input data has quietly made the system worse. With one, you find out before your customers do.
Which models we build on
We are not locked to one model. Anthropic's Claude is the usual default, accessed through enterprise rather than consumer platforms, with OpenAI's GPT models, xAI's Grok and open-source models used where they are the better fit for a specific task. Data handling, retention, hosting location and logging are design decisions we work through with you against your obligations, and we put the answers in writing for the system we build rather than as a blanket claim about every engagement.
We also design for the model layer to be replaceable. Model quality, price and availability have moved substantially every year that this field has existed, and a system welded to one provider's current flagship is a system with an expiry date.
What you get
- An agent design: goal, scope, tool permissions and stopping conditions
- The guardrail and approval model, agreed with your team before build
- An evaluation suite that measures the agent against real cases
- Production deployment with structured logging of the actions it takes
- An operations view showing what ran, what was approved and what escalated
- A runbook for changing the agent's behaviour without calling us
Best fit when
- Work that varies too much for a fixed flowchart but follows a recognisable pattern
- Multi-step research and drafting tasks that currently eat senior time
- Processes spanning several systems where a person is the integration layer
Frequently asked questions
What is the difference between an AI agent and a chatbot?
A chatbot answers. An agent acts. A chatbot can tell you the status of an order; an agent can check the order, find the delay, draft the customer email, apply the credit within policy and update the CRM, then stop at a gate if the credit exceeds your threshold. The difference is tools and permission to use them.
How do you stop an agent doing something it should not?
Three layers. The agent only has the tools we give it, so there is no path to an action we did not scope. Guardrails constrain how those tools may be used: spend limits, policy checks, data boundaries. And approval gates stop anything consequential until a person says yes. Actions are logged with their inputs, at a level of detail agreed during design, so what happened can be reconstructed afterwards.
What happens when the model gets it wrong?
It will, sometimes; anyone who tells you otherwise is selling something. The design assumption is that it will. Confidence thresholds catch the cases where it is uncertain, evaluation suites catch systematic drift, gates catch the consequential mistakes before they land, and logs let you trace what happened. The goal is a system whose errors are caught, visible and cheap, rather than one that never errs.
Do agents replace our staff?
In the work we do, they remove the administrative layer around people's jobs (the re-keying, the chasing, the document assembly) rather than the jobs themselves. The realistic outcome is that the same team handles materially more volume, and spends its time on the parts of the work that need a person.
How much does an agent cost to run?
Ongoing cost is model usage plus hosting, and it scales with volume rather than headcount. We size it during design so you know the per-run economics before you commit to a build, and we design the workflow so the expensive reasoning only happens at the steps that need it.
More questions answered on the full FAQ.
Read next
Digital staff that take the action.
Tell us about the process you'd point this at. Thirty minutes, no preparation, and a straight answer on whether Agentic AI Design is the right first move, or whether something else on the list is.