Custom AI agents built for your trade

Build an AI agent around one useful workflow: the systems it
connects to, the cases it is evaluated against, the actions a person
approves and the access it receives. We agree that scope with your
domain experts and choose a model using those requirements. The
integration and evaluation record remain part of your deliverable
when the model changes.

Connected: to the systems the work lives in

An agent that cannot reach your systems can only talk. We connect it
to the ones the work happens in — the ERP, the CRM, the booking
system, the mailbox, the document store — each through a described
tool with a narrow job: look up a vessel, draft a quote, file a
case. Tools are offered over MCP or an API, every input is typed and
validated, and an agent that needs your company's own records reads
them from data made ready for it. Memory of past cases lives in your
database, not in a vendor's chat history.

Measured: against cases your experts write

Without tests, "it seems better" is the only measurement anyone has.
We sit with the people who do the work and write down real cases
from your trade, each with the answer a senior person would give.
Every change — a prompt, a tool, a model — runs against all of them
before it ships, and the score is kept per case over time, so review
can reveal regressions in the agreed cases. It is the quality gate
we run on our own code, applied to an agent's answers.

Supervised: a person decides where it matters

Not every action should be the agent's alone. We write down, with
you, what it may do on its own, what it drafts for a person to
approve, and what it never touches, and the rules are enforced in
the tools rather than asked for in the prompt. A review screen shows
a person what the agent proposes and why; a correction made there
becomes a new test case. Every step is traced with OpenTelemetry, so
when an answer goes wrong you can see which tool, which document and
which model produced it.

Evaluate model changes before rollout

Model choice is configuration where the integration permits it. We
compare a candidate against your agreed cases for answer quality,
failure behavior, cost and latency. The evaluation informs a
deployment decision; a newer model does not automatically improve
your workflow. Changes go through the agreed review and rollout
process, with the previous configuration available for rollback.

The work behind it

The habits that make an agent trustworthy are the ones we already
keep in our own engineering. We built a guard engine of 268 commit
checks and a commit gate of 22 linters with no warning tier, then
wrote tests for the checkers themselves so a check that reads
nothing cannot report clean. We built first-party error monitoring
and tracing, made six collectors state what they skipped, and ran a
whole development programme as 51 written initiatives, each with its
measurements and the decisions it declined. This site's own
readiness for agents was built the same way.

How an engagement runs

It starts with one task and its cases. We sit with the people who do
it, write down thirty to fifty real examples with the right answers,
and agree what the agent may do alone. Then we build the smallest
agent that passes them, behind a review screen, in your
infrastructure or your cloud account, with its access locked to what
it needs. Then the next task. You own the code, the cases and the
data, so the agent stays yours when the model under it changes. It
is bought like the rest of our work, on the terms in what it costs.

If there is work in your trade that an agent should take off
somebody's desk, tell us what it is (read by the engineer).

hThis page on the web	URL:https://support.engineer.company/ai-agents/	support.engineer.company	70
