How a project runs, from requirement to delivery
Six phases, each with a clear output. Every phase removes a risk before the next one starts, and you always know what we need from you and what you will receive.
- 1
Discover
Understand the problem and the people
We sit with the person who owns the task and map how it is done today, step by step, before anyone proposes a solution.
What we do
- Run a discovery session with the task owner and the people who do the work
- Map the manual steps, the systems involved and where the time goes
- Collect real examples, including the awkward ones
- Note data, security and compliance limits early
What we need from you
- A named owner for the task
- Ten to twenty real examples
- A list of the systems the work touches
You get: A requirements brief: the task, the users, the systems and the data rules.
- 2
Define
Agree the scope in writing
Requirements become a short contract that says what the agent will do, what it must never do and how success is measured.
What we do
- Narrow the work to one task with one definition of done
- List the tools the agent may call and the actions it may never take
- Choose model and hosting against accuracy, cost and where data may go
- Write the plan, the milestones and an estimate
What we need from you
- Sign-off from the task owner
- Sign-off from security or data protection where they apply
You get: A signed task contract and a milestone plan with an estimate.
- 3
Prototype
Prove the hard part first
We build a thin version that runs end to end on real examples, so risks show up in days instead of months.
What we do
- Build the thinnest working slice of the whole flow
- Turn your examples into the first evaluation set
- Score the prototype and share the baseline openly
- Decide together what to fix, cut or keep
What we need from you
- A short review session each week
- Feedback on real outputs, including the wrong ones
You get: A working prototype and its first scores on your own examples.
- 4
Build
Build and integrate
The full system is built in small steps, each one scored against the evaluation set so quality only moves forward.
What we do
- Build the agent loop, retrieval and tool layer
- Connect to your systems through narrow, typed and logged tools
- Score every change against the evaluation set
- Add tracing so every run can be replayed
What we need from you
- Staging access to the systems involved
- Answers to questions as they come up
You get: The agent running in staging, integrated with your systems, with traces and scores.
- 5
Launch
Add guardrails and go live safely
Before launch we test how the system fails, add the limits and approvals, and start with a small group.
What we do
- Add permissions, approval steps and fallbacks
- Test bad inputs, edge cases and misuse on purpose
- Set up monitoring and alerts for unsure or wrong behaviour
- Run a pilot with a small group and agree a go or no-go from the scores
What we need from you
- A small pilot group
- The go or no-go decision
You get: A production release with monitoring, alerts and an approval flow.
- 6
Hand over
Hand over and support
Your team ends up owning the system, with everything needed to run, change and trust it.
What we do
- Move the code and configuration to your repository
- Write the runbook for running, updating and debugging
- Walk your team through the system and the evaluation set
- Stay available through an agreed support period
What we need from you
- The people who will own it, in the walkthrough
You get: Code in your repository, a runbook, a trained team and a support period.
Principles behind the process
Measure before you polish
A test set grows with the agent, so every change is scored. Nothing ships on a feeling.
Narrow tools, narrow permissions
Each tool does one job with the least access it needs. Destructive actions need approval.
Every run leaves a trace
When something goes wrong, you can replay the run and find the step that failed.
Hand over, do not hold on
Code in your repository, documentation your team can follow, no hidden dependencies on us.
Common questions
How long does a project take?
It depends on the task. After the Define phase, we give a written estimate for the first working version. We will not guess before the task and its limits are written down.
Who owns the code?
You do. It lives in your repository from the start, and the hand-over phase makes sure your team can run it.
What do you need from us?
A person who owns the task, access to example data, and a few hours of their time each week to review results.
What if the prototype shows the idea will not work?
Then we say so early, with the scores to show it. Finding that out in the Prototype phase costs far less than finding it after the full build.
Do you support the system after launch?
Yes. A support period is agreed in the Define phase, and the hand-over includes a runbook so your team is never dependent on us.
Let us open a conversation.
Have an agent or an automation in mind, or a collaboration to explore? Tell us what you want to build. We reply to every message with an honest view of fit and next steps.