AI agents
Autonomous, tool-using agents that complete real work — not just chat.
An agent that works in a demo and an agent that works on a Tuesday afternoon with real data are different pieces of software. The gap between them is evaluation, guardrails, retries, logging and a clear boundary around what the agent is allowed to do unsupervised. I build agents starting from that boundary — we decide what it may touch, what requires a human approval, and how we will know when it is wrong, and only then wire it into your systems.
What you get
- Typed tool definitions with strict schemas and useful error messages
- Agent runtime with retry, timeout and escalate-to-human behaviour
- Permission matrix classifying every action: auto, approval, or forbidden
- Evaluation harness built on 50–200 labelled cases from your own history
- Structured run logs capturing plan, tool calls, inputs and outputs
- Dashboards for accuracy, escalation rate, latency and cost per task
- Shadow-mode runner that compares agent decisions against your team's
- Documented kill switch any member of your team can operate
Outcomes you can expect
- A measured accuracy number against real cases, not a vendor claim
- Regression suite that catches drift when a prompt or model changes
- Cost per task readable off a dashboard, with per-day budget caps
- Irreversible actions gated behind human approval by default
- Hours a week returned to the team currently doing this by hand
- A rollout you can halt instantly without calling a developer
What those actually mean
Every item above is something you can check for yourself after launch — not a promise that only becomes measurable once the invoice is paid. Here is the reasoning behind the ones that matter most.
An evaluation harness built before the agent ships
A graded set of real cases drawn from your own data, with pass thresholds agreed up front. You get a number for how well it performs, and a regression suite that catches the day a prompt or model change quietly makes it worse.
Explicit permission boundaries
Every tool the agent can call is enumerated and classified: safe to run unsupervised, requires approval, or forbidden. Irreversible actions sit behind a human confirmation by default.
Full traceability on every run
Each execution logs its inputs, plan, tool calls, and outputs, so when someone asks why the agent did something in March, there is an answer rather than a shrug.
Cost controls that hold under load
Per-run and per-day token budgets, model routing that reserves the expensive model for the steps that need it, and caching on repeated context. You see cost per task, not just a monthly invoice.
Graceful failure instead of confident nonsense
The agent is built to escalate when it is uncertain, with retries, fallbacks, and a defined hand-off path to a human. An agent that knows when to stop is worth more than one that always answers.
A rollout plan that starts in shadow mode
The agent first runs alongside your team without acting, so you can compare its decisions against theirs on live traffic before it touches anything real.
The engagement, phase by phase
This is the actual sequence, including how long each phase takes and what is expected from you at each point.
Workflow archaeology
1 weekBefore automating anything, I document how the work is done today — including the exceptions your team handles without thinking about them, which are usually where automation fails.
- Shadow sessions with the people currently doing the work
- Written step-by-step of the current process, exceptions included
- Volume and cost baseline — how many, how long, what it costs today
- Honest assessment of which steps should stay human
Eval set & success bar
1 weekWe agree what 'working' means numerically before building, using real historical cases with known-correct outcomes.
- 50–200 real cases assembled and labelled from your own history
- Grading criteria defined per case type, including partial credit
- Pass threshold agreed — the number the agent must beat to ship
- Baseline measured on a naive implementation for comparison
Agent build
3–6 weeksTools first, then the reasoning loop. Most agent failures are actually tool design failures — vague descriptions, sloppy schemas, unhelpful errors.
- Typed tool definitions with strict schemas and useful error messages
- Reasoning loop with retry, timeout and escalation behaviour
- Integrations against your real APIs, in a sandboxed environment
- Eval run on every change, with results tracked over time
Shadow deployment
2–3 weeksThe agent runs on live traffic and records what it would have done, without doing it. This is where the remaining edge cases surface.
- Side-by-side comparison of agent decisions against human ones
- Disagreement review sessions with the team that owns the work
- Prompt, tool and threshold tuning against real disagreements
- Go/no-go decision based on measured agreement rate
Staged rollout & monitoring
2 weeks +Autonomy is granted gradually, by category, with a kill switch that any member of your team can operate.
- Start with the lowest-risk category at partial volume
- Dashboards for accuracy, escalation rate, latency and cost per task
- Alerting on accuracy drift and on cost anomalies
- Documented kill switch and manual-override procedure
Where this works — and where it doesn't
Turning down the wrong project is cheaper for both of us than discovering the mismatch in week four.
- Teams whose staff spend hours a day on repetitive, rules-shaped judgement work
- Support desks drowning in triage, tagging and routing before a human even reads a ticket
- Operations that copy data between systems that were never designed to talk
- Companies that ran an AI pilot, got 70% accuracy, and could not close the gap
- Anything where a wrong answer is unrecoverable and no human review is acceptable
- Replacing a deterministic script that already works — a rules engine is cheaper and better
- Fully autonomous financial or legal decisions without a person signing off
- Projects with no access to representative real data for evaluation
What you own at the end
Everything below transfers to you on completion. There is no proprietary layer you have to keep paying me for, and no account that stays in my name.
- Agent source code, prompts and tool definitions, version-controlled
- The complete evaluation harness and labelled case set
- Monitoring dashboards and alert configuration
- Runbook: how to add a tool, adjust a threshold, or disable the agent
- Cost model showing spend per task at your current volume
- Training session for the team who will operate it day to day
AI agents — the usual questions
The things people ask on the first call, answered before you have to.
I won't quote a number before seeing your data — anyone who does is guessing. What I will commit to is measuring it honestly against real cases, agreeing the threshold with you before we build, and telling you plainly if the task turns out not to be a good fit for automation.
Let's scope your ai agents project.
A 30-minute call, a written scope within two working days, and a price you can plan around.