AI agents and agentic workflows
Tool-using agents built on LangChain and LangGraph — with evaluation, guardrails, approval gates and a hard cost ceiling.
An agent demo is easy and an agent in production is not. The demo runs once, on a clean input, with someone watching. Production means a thousand runs a day on messy inputs, where a wrong tool call writes to a real system, a retry loop can burn a five-figure invoice overnight, and nobody is watching at 3am.
We build the boring machinery that makes the difference. Explicit state graphs in LangGraph rather than an agent improvising control flow, so a run can be inspected, resumed and replayed. Tools with narrow, allow-listed permissions and hard limits on value and volume. Approval gates on anything consequential. Full tracing of every step, tool call and token.
And an evaluation harness before the feature, not after. A golden set drawn from your real inputs, task-appropriate scoring, and a regression suite that runs on every prompt or model change — which is what lets you swap models, cut costs and know immediately whether quality moved.
The parts that matter.
- 01
Agentic workflow engineering
Explicit state machines in LangGraph with checkpointing, so long-running workflows survive restarts, wait on human approval, retry safely and can be replayed from any step.
- 02
Tool and system integration
Agents that call your real APIs and databases through narrow, allow-listed, least-privilege tools with schema-validated arguments — never a broad credential and an open prompt.
- 03
Multi-agent orchestration
Supervisor and specialist patterns where the task genuinely decomposes, with explicit handoffs and termination conditions instead of agents talking to each other indefinitely.
- 04
Retrieval and memory
Permission-aware retrieval over your documents and records, plus scoped short and long-term memory, so an agent has the context it needs and nothing it should not see.
- 05
Evaluation and observability
Golden datasets, automated scoring, side-by-side model and prompt comparison, full run tracing, and dashboards for latency, token spend and failure modes per workflow.
- 06
Guardrails and cost control
Prompt injection defence, PII redaction, output validation against a schema, mandatory human sign-off above a threshold, and per-workflow budget ceilings enforced in code.
What you
actually receive.
Named artefacts, not a status report. Every item here is something you can open, run or hand to another engineer.
- 01Agent workflows as inspectable, resumable state graphs
- 02Evaluation harness with a golden dataset from your real inputs
- 03Least-privilege tool layer with allow-listed actions and hard limits
- 04Full run tracing: every step, tool call, token and cost
- 05Shadow-mode results comparing agent decisions against human decisions
- 06Budget ceilings and alerting so runaway loops cannot invoice you
Before you ask.
What stops an agent from doing something damaging?
Layers, not trust. Scoped credentials, an allow-list of permitted actions, schema validation on every tool argument, hard caps on value and volume, mandatory approval above a threshold, and a complete replayable log. Agents get the same least-privilege treatment as any other service account.
LangChain, LangGraph, or something else?
LangGraph where control flow matters, because an explicit state graph is inspectable and resumable in a way a free-running agent loop is not. LangChain for the integration and retrieval layer. We are not dogmatic — plenty of workloads are better served by plain code calling a model directly, and we will say so.
How do you keep token costs predictable?
Model routing by task difficulty, aggressive prompt caching, batching, and smaller models on high-volume paths. Cost per run is a tracked metric from week one with a hard ceiling enforced in code, so a bad loop fails closed instead of billing you.
How is this different from your AI automation practice?
Automation is about taking a known process off your team's hands, mostly with deterministic code and AI only where judgement is needed. Agents are for work where the steps are not known in advance and the system has to decide what to do next. Many engagements use both.
Tell us what you are building.
A short conversation is usually enough to tell whether we are the right firm for the problem. If we are not, we will say so and point you somewhere better.