Model, tools, APIs, databases, browser, servers and your business logic — wired into one system that runs a process end to end, and hands off to a human exactly where it should.
illustration support-agent
⏸ paused · awaiting human approval
run a real one →How it works
This is a real support-and-billing agent, end to end. Every arrow is a place where most demos break — a wrong schema, a stale record, a hallucinated policy, an invoice nobody approved. Those are the parts I build for.
ingest
Request in
email · form · hook
understand
Typed intent
structured output
gather
CRM lookup
tool calling
Policy retrieval
RAG · cited
decide
Decide & draft
grounded
act
Write records
idempotent
Send reply
action
Raise invoice
action
gate
Risk gate
confidence · spend
outcome
Auto-complete
no human
Human queue
with full context
Receives the request
Email, chat, form or webhook lands in a single typed entry point.
Understands the intent
Structured outputs turn free text into a validated schema — no guessing downstream.
Checks the CRM
Tool calls pull the account, plan, history and open tickets before anything is written.
Searches what it doesn't know
Hybrid retrieval over docs, tickets and policies with citations attached to every claim.
Generates the response
Grounded, on-brand, and refused outright when the context doesn't support an answer.
Updates the database
Idempotent writes, audit trail, and rollback on partial failure.
Acts in your systems
Sends the email, creates the invoice, books the slot — through APIs or a real browser.
Escalates to a human
Confidence, risk and spend thresholds route the edge cases to a person, with full context.
The escalation is the feature. An agent that knows when to stop is worth more than one that always answers.
Plan yours live →Live demo
A real agent reads it, plans the pipeline, names the failure mode of every step, and marks where a human has to sign off — returned as schema-constrained JSON, streamed, with the real token count and cost underneath. It will also tell you when an agent is the wrong answer.
architect · one model call
Idle. The agent takes your description, plans the pipeline, and returns it as schema-constrained JSON — one call, streamed, with the real token count and cost below.
no run yet
Who it's for
The architecture barely changes between sectors — the systems and the rules do. Here's where that loop tends to be worth automating first.
Contract clause review · Matter intake · Deadline docketing
Invoice & receipt extraction · Ledger coding · Month-end chasing
KYC onboarding checks · Reconciliation · Reporting packs
Claims intake triage · Policy Q&A · Renewal follow-up
Lease abstraction · Maintenance triage · Listing enrichment
Appointment intake · Eligibility checks · Referral routing
CV screening · Interview scheduling · Onboarding packs
Order & refund triage · Supplier email parsing · Catalog enrichment
Shipment chasing · POD & BOL extraction · Exception handling
RFI routing · Quote takeoff from drawings · Subcontractor follow-up
Client intake · Proposal drafting · Reporting roll-ups
Status roll-ups · Meeting notes → tasks · Risk register upkeep
Regulated work
In legal, medical and financial work the agent drafts and a human signs off. That's a design constraint I build in from the start, not a limitation I ran into.
Not on the list?
The pattern usually transfers. Describe the process and I'll tell you which steps an agent should own — and which it shouldn't. Ask me.
Capabilities
Anyone can call a model. The work is everything around it: typed contracts, scoped tools, retrieval that cites, routing that controls cost, evals that catch regressions, and traces that tell you why a run went sideways.
Multi-provider integration, streaming, retries, token budgeting and cost control.
Schema-constrained generation so downstream code gets typed data, not prose.
Well-scoped tools with strict arguments, timeouts and side-effect boundaries.
Chunking, hybrid search, reranking and citation-backed answers over your corpus.
Index design, metadata filtering and refresh pipelines that stay in sync with the source.
Model Context Protocol servers and clients that expose your systems to any agent runtime.
Single-agent loops, planner/executor splits and multi-agent handoffs — chosen, not defaulted.
Durable, resumable orchestration with retries, checkpoints and human approval steps.
Agents that operate real UIs when there is no API — with guardrails on what they may click.
Right model per step, with fallbacks and quality/latency/cost tradeoffs made explicit.
Golden sets, regression suites and LLM-as-judge scoring wired into CI before you ship.
Prompt-injection defence, least-privilege tools, secret hygiene and output validation.
Traces per run, step timings, token spend and failure taxonomies you can actually query.
Open-weight models in your own VPC or hardware — data never leaves, no per-token bill, no vendor lock-in.
Workshops, pairing and code review that leave your engineers able to build and run this without me.
What I build
Your process is specific, but the architecture usually isn't. Start from the closest shape and we adapt it to your systems, your data and your risk tolerance.
Triage, answer, update, invoice
Handles inbound requests end to end: reads the message, checks the CRM, retrieves policy, drafts the reply, updates records, raises the invoice and escalates anything risky.
Answers with citations
A retrieval system over your documents, tickets and databases that answers with sources, admits uncertainty and stays fresh as the underlying content changes.
Works where there is no API
Agents that log in, navigate legacy portals, extract data and complete forms — deterministic where possible, model-driven only where it has to be.
Long-running, crash-safe
Multi-step business processes as durable workflows: each step retried, checkpointed and observable, with approval gates where money or reputation is involved.
Process
Short cycles, working software early, and a hard line between what's demoed and what's production-ready.
We map the real process — inputs, systems, decisions, who signs off — and agree what the agent is allowed to do without asking.
A working thread through the full path within days: real tools, real data, real failure cases, no demo shortcuts.
Evals against a golden set, prompt-injection and permission tests, tracing, cost caps and a human-in-the-loop path for the tail.
Deploy, watch the traces, tune routing and prompts against measured regressions — and hand over documentation your team can run with.
Twenty years of enterprise IT came first: cloud architecture, systems integration, infrastructure and the digital transformation programmes that come with them. Long enough to learn why automation projects fail, and it is almost never the model.
I build AI agents and the systems around them. The model call is the easy part; everything else — typed contracts between steps, tools scoped to what they're allowed to touch, retrieval that cites, routing that controls cost, evals that catch regressions before your customers do — is the actual work.
That background is why these agents survive contact with a real business. They have to reach your CRM, your billing, your legacy portal and your approval chain, in an environment where downtime and audit trails matter. I work end to end, from mapping the process with the people who run it today to operating it in production — and I'll tell you when an agent is the wrong answer, which happens more often than the market admits.
Start a conversation →Questions
If yours isn't here, ask it in the form below — I answer these the same way in email.
Because the hard part of an agent isn't the model, it's everything I already spent two decades on: making systems that were never designed to talk to each other work together, somewhere downtime and audit trails matter. Agent projects rarely fail on prompting. They fail on integration, permissions, and the edge cases nobody mapped.
Days for a real thread through the full path — real tools, real data, real failure cases. Weeks to production, driven mostly by how many of your systems it touches and how long access takes.
A sandbox or test account for each system involved, a sample of real inputs (redacted is fine), and one person who actually owns the process and can settle the judgment calls.
You do. It deploys into your accounts and your repos, documented well enough that your team can run it without me. No proprietary runtime, no lock-in.
It will, and the system is designed for it: evals against a golden set before release, confidence and spend thresholds that route edge cases to a person, idempotent writes, and a trace per run so you can see exactly which step went sideways.
Least-privilege credentials scoped per tool, secrets never in prompts or model context, prompt-injection tests on anything that reads untrusted input, and providers configured so your data isn't used for training.
Measurable per run, and I'll show you the number before you commit. Model routing, caching and effort settings are the levers — most workflows land in cents per run, not dollars.
Yes. I can build it and hand it over with documentation, or embed with your team and leave them able to extend it. Both are normal.
Contact
Straight answer either way — including when a script, a rules engine or a better form would beat an LLM. If it's a fit, you get a scope and a first working thread within days.