01Discovery
We map the workflow, the systems, the volumes and the exceptions.
You getA written opportunity assessment with the cost of the status quo.AI & Automation
AI agents that do the work, not just answer questions.
We design, build and operate autonomous agents that qualify leads, triage support, reconcile data and run multi-step workflows end to end, inside the systems your team already uses, with a person in the loop wherever being wrong would be expensive.
At a glance
- First agent live
- 6–8 weeks, typical
- Models
- Model-agnostic, commercial or open-weight
- Integrates with
- CRM, ERP, ticketing, email, internal APIs
- Control
- Approval gate on anything irreversible
- Engagement
- Fixed-price pilot, then dedicated team or T&M
- Ownership
- Your code, your repositories, your cloud
The distinction that matters
An assistant replies. An agent finishes the job.
Most organisations have already tried a chatbot. It answered questions, deflected some tickets, and left the actual work exactly where it was. An agent is a different thing: it is given a goal, a set of tools and a boundary, and it operates inside your systems until the task is complete or it needs a human.
That shift (from answering to acting) is what makes agents worth the engineering. It is also what makes them harder to build well. An agent that acts on your live systems has to be constrained, observable and reversible, or it will create more work than it removes.
The failure mode is rarely the model. It is the plumbing around it: whether the agent can see the right data, whether it has real permission to act, what happens when it is unsure, and whether anyone can reconstruct afterwards what it did and why.
That plumbing is the majority of the build, and it is the part we have spent 23 years doing for enterprise systems that could not afford to break.
Anatomy of a working agent
01TriggerA form, an email, a record change, a schedule.
02GatherPulls the context it needs from your systems.
03DecideChooses the next step within defined boundaries.
04ActWrites back, sends, files, updates; through real APIs.
05VerifyChecks its own work against your rules.
06CloseCompletes, or escalates with the full trail attached.
Choosing the right tool
Not every process deserves an agent.
We would rather talk you out of one than sell you the wrong thing. This is the test we apply before proposing anything.
| If the process… | Use | Because |
|---|---|---|
| Has stable rules and structured input | Rules-based automation (RPA) | Cheaper to run, trivially auditable, and it cannot improvise. Adding a model here buys you nothing and costs you predictability. |
| Varies in wording, format or judgement | An AI agent | The variation is exactly what a rules engine cannot absorb. This is where an agent earns its cost. |
| Is high-volume but mostly routine, with a difficult tail | Agent plus escalation | The agent clears the routine majority; the tail routes to a person with the context already assembled. |
| Is rare, high-stakes and relationship-driven | Leave it with people | Low volume means no payback, and the cost of being wrong is high. Automate the preparation around it instead. |
Where agents pay back first
Six workflows that reliably repay the investment.
These are the patterns we see clear their cost quickest, high volume, well-bounded, and currently absorbing hours of skilled attention.
01
Lead qualification & routing
Enrich, score and route inbound enquiries the moment they arrive, so nothing waits for the next working day.
CRM · web forms · enrichment APIs
02
Support triage & first response
Classify, prioritise and draft the first reply, with the genuinely difficult tickets escalated, not guessed at.
Ticketing · knowledge base · order history
03
Reconciliation & exception handling
Match invoices, payments and ledger entries; surface only the exceptions a person needs to judge.
ERP · banking feeds · ledger
04
Document intake & extraction
Read contracts, claims, forms and statements into structured data, with confidence scores and a review queue.
Document store · OCR · line-of-business system
05
Reporting & management packs
Assemble recurring reports from live systems and write the commentary, ready for a human to sign off.
Data warehouse · BI · email
06
Internal knowledge & onboarding
Answer staff questions from your own policies and documentation, and cite the source so the answer can be checked.
Intranet · HR system · policy libraryWhat we build
Engage us for the whole journey, or the part you are missing.
Most clients start with a single scoped agent and a clear success measure. Some come to us with a stalled internal build and need the integration and governance layer finished properly.
Architecture
How an agent plugs into what you already run.
Nothing is replaced. The agent sits alongside your systems and uses them the way a member of staff would; through interfaces, with permissions, leaving a record.
Your systemsSource of truth
CRMERPTicketingEmailData warehouse
Document storeInternal APIs
↕
OrchestrationWhat we build
Task routingState & retriesTool callingContext retrieval
Escalation rulesExecution log
↕
GuardrailsNon-negotiable
Least-privilege accessApproval gatesEvaluation suite
Cost ceilingsAudit trail
↕
ModelsSwappable by design
Commercial APIsOpen-weight, self-hostedTask-matched routing
No vendor lock-in
Governance
The six questions your risk function will ask.
We build the answers in from the first sprint, because retrofitting them after a successful pilot is where most agent programmes stall.
What can it touch?
Least-privilege service accounts, scoped per agent and per system. It gets the access the task needs and nothing beyond it.
What can it do without asking?
Reversible actions run autonomously. Anything irreversible (payment, deletion, external communication) waits at an approval gate.
Can we see what it did?
Every decision, tool call and input is logged and reviewable, so an outcome can be reconstructed months later.
How do we know it still works?
An evaluation suite runs against every change. Real failures become test cases, so the same mistake cannot return silently.
Where does our data go?
Chosen deliberately, not by default. Where residency or confidentiality demands it, models run inside your own environment.
What stops the bill running away?
Per-task cost instrumented from day one, with ceilings, alerting, and cheaper models handling the routine steps.
How we deliver
Five stages, each with something you can hold.
02Strategy
Use cases prioritised, the first agent scoped, success measure agreed.
You getA costed roadmap and a defined pilot.03Build
Agent developed against your data, with guardrails and evaluation from sprint one.
You getA working agent in staging, reviewable every two weeks.04Integrate & test
Connected to live systems and validated against real historical cases.
You getEvaluation results against your own data, not a benchmark.05Operate
Launch, monitor, retrain and widen scope as confidence builds.
You getMonthly performance and cost reporting, and a documented handover.How the work is staffed
An agent is not finished when it demos. It is finished when it holds.
The gap between a convincing demo and an agent that survives a Tuesday is where these projects are won and lost, and it is almost entirely about your data, your edge cases and your people. That is not work anyone can do from a distance, which is why we staff it with forward deployed engineers.
Embedded, not assigned
The engineer sits inside your rituals and your repository, learning the process the agent is meant to run instead of a written description of it.
Present for the last mile
Real documents, real exceptions, the record that has been wrong since 2014. Nobody finds these from a specification, and they decide whether the agent is trusted.
Accountable for the outcome
Measured on whether the workflow runs in your hands, not on whether the sprint closed. It changes what somebody does when a requirement turns out to be wrong.
There after go-live
Evaluation sets, drift, the prompt that stops working after a model update. An agent with nobody watching it degrades quietly and nobody notices until a customer does.
Your team, alongside
Your engineers work in the same repository from week one. The point is that the capability stays with you when the engagement ends.
The same people afterwards
If you keep the engineer on, they already know the system. If you do not, the documentation was written as we went. Either way there is no re-comprehension bill.
Engagement
Three ways in, depending on where you are.
| Shape | When it fits | Duration | Commercial model |
|---|---|---|---|
| Readiness assessment | You suspect agents apply but cannot yet name the workflow. | 2–3 weeks | Fixed price |
| Pilot agent | One workflow identified, and you want it proven before committing further. | 6–8 weeks | Fixed price |
| Dedicated team | The pilot worked and there is a backlog behind it. | Rolling monthly | Per-person monthly, your backlog |
Questions worth asking
Before you commit to an agent.
The three below are the ones this page does not already answer. Anything more specific, put it to us directly.
How do you control what this costs to run?
Per-task cost is instrumented from the first week, with ceilings and alerting per workflow, so you can see what each completed task costs rather than receiving one opaque monthly number. Cheaper models handle routine steps and expensive ones are reserved for the steps that need judgement, that routing is usually where most of the saving sits. If a workflow stops paying for itself, you will see it in the numbers before we do.
Where does our data go, and who can see it?
That is a decision you make, not one we make for you. Where confidentiality or residency rules require it, we deploy open-weight models inside your own cloud tenancy or data centre, and nothing leaves your boundary. Where a commercial API is acceptable, we use providers with zero-retention terms and restrict what is sent to the minimum the task needs. Either way, the agent sees only the systems and fields you scope it to, and every retrieval is logged.
What happens if we want to take it in-house later?
You own the orchestration code, the prompts, the evaluation sets and the integration layer, they are in your repositories from the first commit, not ours. Because the build is model-agnostic, you are not tied to a provider either. We hand over with documentation and a working session for your engineers; a number of clients run their agents themselves now and call us only when they want another one built.
Related capabilities