AI agents & workflow automation
One process, end to end: an agent that reads context, calls the systems it is permitted to call, does the work, and hands off cleanly when it should not proceed. Built as software, not as a prompt.
A demo is a
happy path.
Building an agent that works once is an afternoon. Building one that runs 4,000 times a month without quietly doing the wrong thing is engineering — and it is almost entirely about the parts a demo never shows: what happens on the fifth retry, what the agent is allowed to touch, what it does when a system returns something it has never seen, and how anyone finds out.
The failure mode is rarely a crash. It is an agent that keeps running, keeps looking successful, and keeps producing subtly wrong output that nobody catches for six weeks.
We treat the model as one component in a system that has permissions, validation, retries, logging and a stop condition — because everything that makes an agent trustworthy lives outside the prompt.
What a production agent contains
Six layers. Only one of them is the model.
Trigger
What starts a run: a webhook, a queue message, a schedule, a new row, an inbound email. Runs are idempotent and deduplicated, so a retried trigger does not do the work twice.
Tools, scoped
Every system the agent can reach is an explicitly defined tool with typed inputs and a least-privilege credential. Read-only where reading is enough. Nothing is reachable because it happened to be on the same network.
Deterministic guardrails
The rules that must always hold — spending limits, approval thresholds, allowed recipients, mandatory fields — enforced in code before the action executes, not requested politely in a system prompt.
Failure & escalation
Bounded retries with backoff, a hard iteration cap so an agent cannot loop indefinitely, and a defined handoff: which human, through which channel, with what context attached.
Observability
Every run logged with its inputs, tool calls, token spend and outcome. You can answer "what did it do on the 14th, and why" without reading a model's mind.
Evaluation set
A frozen set of real scenarios with known-correct outcomes, including the ones designed to make it fail. Re-run on every change, so an improvement to one case cannot silently break another.
One process, fixed price
Prices in Canadian dollars, verified 23 August 2026. Scope is one process — a second process is a second engagement, priced from what we learned in the first.
Agent Pilot
from $22,000CAD · One process, up to three connected systemsIncluded
- All six layers above, running in production
- Frozen evaluation set with agreed pass threshold
- Run-level logging and cost dashboard
- Runbook, architecture notes and full source
- Two weeks of post-launch tuning
Not included
- Additional processes
- Ongoing hosting — see Resident Care
Multi-system agent
to $55,000CAD · Complex process, five or more systems, approval workflowIncluded
- Everything in Agent Pilot
- Five or more connected systems
- Multi-step human approval with role-based authority
- Legacy-system integration where no clean API exists
- Load and failure testing before cutover
Not included
- Building APIs your vendors don't provide
- Licence costs for third-party systems
Resident Care
$2,500–$9,000CAD / month · Three tiers by response time and change budgetIncluded
- Hosting in your chosen region, or your own tenancy
- Monitoring, alerting and incident response
- Evaluation set re-run on a schedule
- A monthly change budget for tuning and small additions
Not included
- LLM inference — at cost, or your own API account
- New processes or major re-architecture
Where the pilot lands between $22,000 and $55,000 is decided during scoping, and written into the statement of work before any code exists. We do not start a build on a range.
When a platform is the better answer
If your process is a linear chain of API calls with no real judgement in it, a workflow tool will do it for a subscription fee and you should buy one. We will tell you that in the scoping call rather than after the invoice.
Custom engineering earns its cost in three situations: the process needs genuine judgement on unstructured input, the systems involved have no clean API, or the data cannot leave a region or a network. If none of those is true, you are buying bespoke software to do something a subscription already does.
See the full build-vs-buy comparisonWhat you own at handover
Source code, infrastructure definitions, prompt and tool specifications, the evaluation set with its labelled data, and a runbook another engineer can follow. No runtime licence, no per-seat fee, no lock to us.
If you later want to take it in-house, the handover session is included and the code is written to be read by someone who was not in the room.
When being wrong is expensive and cannot be caught. Automation is a bet on a distribution of outcomes. If a single bad decision costs more than a year of the labour you are saving — and no human reviews it before it lands — the arithmetic does not work regardless of accuracy.
When the process only exists in one person's head. We cannot encode rules nobody has written down. If the answer to "what happens in this case?" is always "it depends, ask Dana," the first project is documenting the process, not automating it.
When the volume is a handful a week. A $22,000 build against three hours a month of work is not an investment, it is a hobby. Bring the volume number to the call.
An agent loop that has to survive real inputs
IMS is our own live incident tracker: continuous ingestion from RSS, JSON and government feeds that disagree about everything, then classification, a live console and verifiable exports. It is where the retry, human-gate and runbook patterns on this page were proven.
Our own product, not a client engagement. We have no client case studies yet and will not invent any.
Questions worth asking first
If yours is not here, bring it to the scoping call — along with the volume number.
Is the price fixed before you start?
Where the pilot lands inside the published range is decided during scoping, and written into the statement of work before any code exists. We do not start a build on a range. Scope is one process — a second process is a second engagement, priced from what we learned in the first.
What stops the agent doing something it should not?
The rules that must always hold — spending limits, approval thresholds, allowed recipients, mandatory fields — are enforced in code before the action executes, not requested politely in a system prompt. Every system the agent can reach is an explicitly defined tool with typed inputs and a least-privilege credential, read-only where reading is enough. Nothing is reachable because it happened to be on the same network.
What happens when a run fails or the agent gets stuck?
Bounded retries with backoff, a hard iteration cap so an agent cannot loop indefinitely, and a defined handoff: which human, through which channel, with what context attached. Runs are idempotent and deduplicated, so a retried trigger does not do the work twice.
How would we know six weeks later that it is still right?
Every run is logged with its inputs, tool calls, token spend and outcome, so you can answer "what did it do on the 14th, and why" without reading a model's mind. The frozen evaluation set is re-run on every change, so an improvement to one case cannot silently break another. That is the failure this is built against — not a crash, but subtly wrong output that nobody catches for six weeks.
What do we own at the end?
Source code, infrastructure definitions, prompt and tool specifications, the evaluation set with its labelled data, and a runbook another engineer can follow. No runtime licence, no per-seat fee, no lock to us — and if you later want to take it in-house, the handover session is included.
Scope it before you buy it
The readiness assessment maps the process, tests a real sample, and produces a fixed-price build proposal — or a written recommendation not to build.
See the assessment