How we work
Small, testable steps from mapping to handover.
You see working results on sample data before anything touches your systems, and you finish with a workflow your team understands and owns.
- 01
Map
Map the task and success criteria
We walk through the work as it happens today: inputs, steps, tools, owners, and the decisions people make along the way.
- Collect real (or realistic) examples of inputs and good outputs
- Agree what success means and how it will be checked
- Identify where a person must stay in the loop
Output: A written workflow map and success criteria.
- 02
Prototype
Prototype a bounded workflow
We build the smallest version that does the core job end to end, using sample data, so you can judge results before anything touches production systems.
- Build the core path with sample inputs
- Test against the agreed examples
- Review drafts and edge cases with your team
Output: A working prototype and an evaluation of where it falls short.
- 03
Integrate
Connect approved systems
Once the prototype earns trust, we connect it to the systems you approve, with the narrowest permissions that work.
- Set up least-privilege credentials owned by you
- Add exception handling, retries, and alerts
- Add the approval steps agreed in mapping
Output: A connected workflow with a permission inventory.
- 04
Improve
Test, hand over, and improve
We test with your team, hand over documentation and access, and review the first real runs together to decide what to adjust.
- Acceptance testing against the success criteria
- Handover notes, run logs, and ownership of credentials
- A short list of improvements, prioritised with you
Output: A workflow your team understands and can operate.
Scope
Scope is agreed before building starts.
After mapping, we propose a written scope: the workflow, the systems, the review points, what “done” means, and what is out of scope. Price follows scope — we don’t publish fixed packages, because effort depends on the specifics.
What we’ll need from you
- A person who knows the workflow and can review results
- Real or realistic examples of inputs and good outputs
- Access to the systems involved, granted by you, at the narrowest level that works
- Decisions on where approval is required
Limitations
Honest about what can go wrong.
Good automation is designed around its failure modes. These are the ones we plan for from day one.
AI output can be wrong
Language models can produce confident, incorrect answers. That is why we evaluate against examples, flag uncertainty, and keep review steps on anything consequential.
Integrations depend on APIs
What we can connect depends on each tool’s API, plan, and permissions. We check feasibility during mapping and say so early if something isn’t possible.
Workflows need upkeep
Tools change and processes evolve. Handover includes documentation and run logs so changes can be spotted and made deliberately.
How we build
Engineering principles we design around.
These describe how we approach every project. They are design commitments, not guarantees about how any particular system will behave.
- 01Observability
- Every run should leave a trace: what came in, what the agent did, and what it handed to a person. If you cannot see it, you cannot trust it.
- 02Least privilege
- Each connection gets the narrowest access the task needs. Read-only where possible, draft-only before send, nothing beyond scope.
- 03Evaluation
- We test against real examples before rollout and keep the test set, so changes can be checked rather than guessed.
- 04Human handoff
- Uncertain cases and consequential actions go to a person, with the context they need to decide quickly.
Start with the mapping conversation.
Tell us about the workflow you have in mind. If it’s a good fit, the first step is mapping it together.