Home / How we work

We build it, then we get out of the way.

Four steps, each producing something you keep. The measure of a good engagement is that by the end your team could run it without us — so this page is mostly about how the work moves off our desk and onto yours.

Who does the work

The load has to move, or we've failed.

Agencies rarely publish this, because the honest version shows them becoming unnecessary. That's the point.

Your security team is heaviest at step two, when the rules get written. That's deliberate — rules written without them get switched off within a month.

Effort by stage / indicative
None Light Shared Leading

By step four we're in a weekly review, not a workstream. Plenty of clients drop that to monthly and then to nothing, which is the outcome we're aiming at — the platform stays, the engagement doesn't have to.

The four steps

Each one leaves something behind.

No discovery theatre and no deck at the end. Every step produces an artefact you'd still have value from if we walked away that afternoon.

Step 01

Find the work worth handing over

We sit with the team actually doing the job — not their manager — and map the workflow as it really runs, including the bits nobody documented. Then we pick the one with the clearest before-and-after.

If nothing clears the bar, we say so and you've spent a fortnight learning your own process better than you knew it. That happens more often than you'd expect and we'd rather it happened here than in month five.

What you keep

  • A workflow map of how the job runs today, with the undocumented steps
  • A baseline: volume, time per task, current error rate
  • A ranked shortlist, with the ones we'd decline and why
Step 02

Design the agent and its limits together

Prompts, tools, memory and retrieval — plus the rules it runs under. What it can reach, what it can spend, and what it must ask a human about first, all decided before anything ships.

Your security team is in this room. Rules written for a team rather than with one get quietly disabled the first time they block something urgent.

What you keep

  • An agent spec: tools, scopes, data reach, failure behaviour
  • A rule set in version control, reviewed and signed off
  • An eval suite defining what correct looks like
Step 03

Ship it where you can watch it

Version-tracked in your repo, deployed into your own AWS, Azure or GCP account, wired into the console before the first real run. It starts at observe — full traces, nothing blocking — until you're ready to let a rule act.

No agent runs dark, not even in staging.

What you keep

  • The agent code, in your repository, under your licence
  • Infrastructure as code for your own cloud account
  • A live console on your traffic, from run one
Step 04

Keep it honest as it grows

Evals on every change, guardrails tuned against real traffic, and a standing review of what got held and why. Repeated holds usually mean a broken workflow rather than a bad agent, and that distinction is most of the work.

Your team takes the console whenever they're ready. We don't hold the keys as a retention strategy.

What you keep

  • A tuned rule set that has survived contact with production
  • A hold log — what was stopped, why, and what changed after
  • A runbook your on-call can act on without calling us
Before you ask

Work we turn down.

Every one of these has been a real conversation. Saying no early costs a deal; saying it in month four costs a reference.

Low volume, high blast radiusIf the job runs eleven times a year and a mistake is catastrophic, a person is both cheaper and better. Automation earns its keep on repetition.
Nobody can define correctIf two people on your team disagree about what a good outcome looks like, no eval suite will settle it and the agent will just automate the argument.
Replacing a team quietlyWe won't build something whose users haven't been told. Aside from the ethics, they're the only people who know how the process actually works.
Locked to one model, foreverIf a constraint means you can never change model provider, we'll flag it as the strategic risk it is rather than quietly building on it.
Ownership

What's yours at the end.

All of it, and from the first commit rather than on final payment. Leaving should be a decision, not a project.

The codeIn your repository from day one, under a licence that doesn't depend on us still being here.
The tracesStreaming to your own bucket as they're written, verifiable without a Spectre account.
The keysDeployed in your cloud account. We never hold production credentials.
The rulesPlain YAML in version control. Readable, diffable and portable by anyone you hire next.
Get started

Bring the workflow you've been avoiding.

The one everybody agrees is a mess and nobody wants to touch. That conversation is free, and it's usually the most useful hour either of us spends.

Book a walkthrough → See pricing