S2 · Build

Agentic Systems Engineering

Multi-step LLM workflows with clean topology, tool surfaces, memory, evaluation, and safety — built to land in production, not stall in a demo.

Most agentic systems fail in production for one of three reasons: the workflow was underspecified, the tool surface was designed backwards from the model, or the evaluation story was invented after the fact. We do this work with the assumption that the interesting engineering happens before the first prompt is written.

If your programme is at the shape-the-workflow stage, we’ll run a short design engagement first and only propose the build once we’ve written down what “done” looks like. If the workflow is settled and the problem is that the current implementation is unstable, we’ll do the surgery on it directly. Either path ends with something the on-call team can maintain without us.

When to bring us in

Signals we're the right fit.

  1. You've got a demo that works in the notebook and stops working the moment there's a second user.
  2. Your first agent worked once and now spends most of its budget in a loop it can't get out of.
  3. You need to ship an agentic workflow past a security review, not just a design review.
  4. The business case rests on one specific task being reliable to two decimal places — and you've never measured it that way.
  5. You've picked "let's use an agent" before "here's the workflow" and it's showing.

How we approach it

The moves that repeat.

  1. Ground in the workflow, not the framework.

    We spend the first week describing the workflow the way an experienced operator would — steps, decisions, hand-offs, edge cases. The agent topology falls out of that; the framework is a footnote.

  2. Design the tool surface deliberately.

    Tools are the API you're forcing the model to reason about. Small surface, sharp names, structured outputs, one clear failure mode per tool. Everything else gets refactored out.

  3. Bound every loop.

    A step budget with a hard stop, tool-scoped budgets, and a self-critique gate at the end. Cost and latency get budgets you actually enforce, not dashboards you look at after a bad week.

  4. Evaluate before it ships and after it lands.

    Offline eval set drawn from real workload traces, online rubrics scored against the live traffic, regression bars that block a deploy. Not a one-off benchmark you can lose to.

  5. Observe like it's a distributed system.

    Because it is. Structured tracing across steps, per-tool metrics, cost-per-trajectory, an ops runbook a human on call can actually follow.

What you get

Deliverables, in plain English.

Deliverable 01

A workflow document.

The reference the whole engineering team agrees on. Steps, decisions, SLAs, out-of-scope list, the failure modes we've thought about. Read once, kept honest by CI.

Deliverable 02

An evaluation harness.

Offline eval set with rubrics and a scoring pipeline. Ships alongside the code, versioned, wired to CI. Regression on a rubric fails the build.

Deliverable 03

An observability + safety kit.

Traces per trajectory, cost budgets enforced in the runtime, guardrail layer where the domain needs one, incident-response runbook, on-call briefing.

Engagement models

Shapes the work comes in.

SPRINT

Bounded first-agent sprint.

Ship one meaningful agentic workflow to production with the platform around it. Named lead, weekly demo, hand-over on the last day.

FIXED SCOPE · 10–16 WEEKS

EMBED

Embedded practice.

Two of our engineers pair with your team on a live problem. We build together; you keep the code, the eval harness, and the habits.

DAY-RATE · ROLLING QUARTERS

Ready to talk about a agentic systems engineering engagement?

A 30-minute discovery call. We'll get to the shape of the work and whether we're the right fit.