Service 01 / 06
AI agents that do the work, not just the talking.
An AI agent is software that completes a task on its own: it looks things up, decides what to do, acts in your systems, and hands over to a person when it should. That last clause is what separates an agent from a chatbot, and it is most of the engineering.
What I build
- It uses your real tools: your CRM, your database, your APIs
- It copes when things go wrong: retries, fallbacks, and a person to hand to
- It remembers the conversation, and who it belongs to
- Every step is logged, so you can see what it did and why
What you get
A working system in your stack that your team can watch, correct and change without me.
Good fit ifsomeone is doing something repetitive that follows rules.
What is the difference between an AI agent and a chatbot?
A chatbot answers; an agent acts. Ask a chatbot to reschedule a delivery and it explains how to reschedule a delivery. Ask an agent and it reads the order, checks the route, writes the change back, and tells you it is done, or tells you why it could not and who now has it.
The distinction matters commercially because it changes what you are buying. A chatbot deflects questions. An agent removes a task from someone's week. The second is worth building; the first is usually a search box with a personality.
What actually gets built
The model is the smallest part. What takes the time is everything around it (the part the industry now calls the harness), and it is where an agent either survives contact with your business or quietly stops being trusted.
- Tools that reach your real systems: your CRM, your database, your internal APIs, not a sandbox that demos well.
- Failure handling: retries with backoff, fallbacks when a system is down, and a defined hand-off to a person when the agent should not decide.
- Memory that belongs to somebody: a conversation that survives a page reload, scoped to an account, with a way to delete it.
- A record of every step: what it read, what it called, what it decided. An agent nobody can audit is an agent nobody will let near a customer.
- Limits: how many turns, how much spend, which actions need a human. Agents are where LLM bills quietly explode, and the ceiling belongs in the code.
How do I know the agent will not go wrong?
You do not, and any answer that promises otherwise is selling. What you can have is an agent that goes wrong *visibly and cheaply*: every step logged, a hard boundary on what it may touch without a human, and a hand-off path that is tested rather than assumed.
The design question is never "will it be perfect": it is "what is the worst thing this is allowed to do on its own". Once that line is drawn explicitly, most of the fear turns out to be about a line nobody had drawn.
The agent on this page is one of these
The chat box on the homepage is not a demo build. It is a production agent with the same shape as one I would build for you: it knows the services, it remembers your conversation across reloads, it can book a call, it can write up a scope note, and if typing gets slow it can ring you, and the voice on the phone is the same brain mid-thought, not a second bot starting over.
It also refuses things, on purpose. It will not quote a price it cannot stand behind and it will not invent a case study. Watching where an agent declines is a better test than watching where it performs.
Questions people ask
- How long does it take to build an AI agent?
- A useful first version of a single-task agent is a week once it has been scoped, not a quarter: the long pole is almost never the model, it is getting clean access to the systems it has to act in. Agents that touch several systems, or that need a human approval step, take longer because the failure paths are the work.
- Will it work with the systems we already have?
- That is the normal case. An agent reaches your CRM, database and internal APIs through tools written against your real endpoints. Where a system has no API, the honest options are a scheduled export, a thin service in front of it, or leaving that step with a person, and which one it is should be decided before the build, not discovered during it.
- What happens when the agent cannot handle something?
- It hands over to a person with the context already attached, rather than apologising in a loop. Designing that hand-off (when it fires, who receives it, what they see) is part of the build, because an agent without one turns every edge case into a dead end for the customer.
- Do we own what you build?
- Yes: your repositories, your cloud accounts, your model provider keys. The code is written to be handed over and documented for whoever picks it up next, which is a deliberate constraint on how it is written, not a document produced at the end.
- What does it cost to run an AI agent?
- Running cost is driven by how many model calls a task takes and which model serves them, and both are design decisions rather than fixed properties. The common failure is routing every step of an agent through a frontier model when most steps are classification and extraction that a small model does identically, which is the whole subject of lowering AI costs.