How we work
Four phases. One team.
Every Kobol engagement runs the same shape. A discovery call, a design phase you can sign off on, a build you can watch happen, and a refine phase where we stay on the line. Same people the whole way through.
01
Discovery call
A call before a contract.
30 minutes with whoever's making the call on operations. We learn how your business actually runs, where AI is supposed to help, and what's already been tried. No deck, no demo. We leave the call with enough context to send you a real proposal, or to tell you we're not the right fit.
What you get
- A scoped engagement proposal with fixed phases and pricing where it can be fixed
- A no-cost recommendation when we are not the right team for the work
- A direct line to the people who would actually be building it
02
Design
Map the system before writing the code.
The design phase is where we go deep. We sit with the people doing the work, inventory your data and tooling, and design the integration end-to-end. Architecture, model choice, fallbacks, escalation paths, monitoring, the whole thing. You see the design before we build it. Anything wrong with it gets caught here, not in QA.
What you get
- A written design doc the engineers will build from
- A prioritised roadmap with effort and payback estimates per integration
- A build SOW you can sign off on or take to another team
03
Build
The same people who designed it ship it.
No handoffs. The engineers in the design call are the ones writing the code. We work in short cycles, demo in your actual workflows instead of slides, and push to staging early so your team can poke at it. We build inside what you already use. We do not rip out what works to sell you something new.
What you get
- A working integration shipped to production
- Documentation your team can actually read and use
- A runbook for what happens when something misbehaves
04
Iterate & refine
We stay on the line.
Production is when AI work actually starts informing your business. Edge cases turn up. Models drift. Workflows change. We stay engaged through the first cycle of real use, fix what breaks because of how we built it, and refine the system as your operations evolve. If it is broken because of us, we fix it free.
What you get
- Ongoing observability and incident response on what we shipped
- Refinement work as the integration meets real volume
- An honest call when it is time to evolve, retire, or hand off
Why these four
It is how the work actually gets done.
We did not pick four phases because four is a nice number. Integrations fail at architecture, not at code, so design lives on its own. Long invisible builds turn into bad surprises, so build is small, frequent, and visible. And production is when the real edge cases show up, so we do not disappear at launch. Most agency engagements break at the seams between phases. For us there are no seams, because the same team runs the whole thing.
Start with a discovery call.
30 minutes, no deck, no pitch. We will talk through your operations and tell you whether there is a build worth doing before we send a proposal.