The Build
You've decided to build. The harder question is how, and how to know it will work on your real data before any of it ships.
The Build
That's where The Build comes in. We work with your team through five phases (prototype, refine, test, iterate, deploy) which is the only honest way to ship something that has to hold up in your real workflow, with the people who'll keep using it. There's a moment about three weeks in where the team realises what's possible: the first MCP server is wired into Claude or Slack, a task that used to take an hour finishes in thirty seconds, and the mood in the room shifts. By the end the agent infrastructure is in production, your team owns it, and the documentation isn't a slide deck. It's the working repo.
The shape of a Build, in detail.
The phases
How a Build actually runs.
- Prototype
- A working slice running in a sandboxed environment, on anonymized or stale data that mirrors what your live system actually carries. Code your team can run by the end of week one, without anything sensitive going near the prototype.
- Refine
- We sit with the people who'll use it day to day, watch what they actually do, and shape the kit around how the work really flows. Still in the sandbox. The team using it tells us what's missing, what's redundant, and what should change.
- Test
- On a wider data sample, in a staging environment that mirrors production. Edge cases, scale, awkward inputs, the corners nobody thought to mention.
- Iterate
- We work through the loop until we're happy with the procedure, then codify it. The patterns become proper agentic prompt templates your team can reuse and extend without us in the room.
- Deploy
- The kit moves from staging into production. The prompt templates ship as part of the documentation. The people who'll run it have already been trained on the live behaviour. Deployment isn't a milestone we charge for, it's the natural end of the cycle.
What we build
The kit your team will own.
- MCP servers
- Bespoke, wired to your data, your tools, your processes. We've shipped sixteen open-source ones already, so we know the patterns that work and the gotchas that bite.
- Integrations
- Slack, Claude Desktop, Notion, Shopify, your CRM, your warehouse. The agent layer doesn't make sense disconnected from where your team actually works.
- Agent UX endpoints
- When the Build includes a customer-facing surface, we ship the WebMCP layer alongside the internal kit. One engagement, both sides of the agentic web.
- Dashboards and observability
- How will you know the kit is still working in three months? We build that in from the start, not as an afterthought.
The output
What you have on day one after we leave.
- Working code in production
- Not a proof of concept, not a deck. Real users, real data, real load.
- A team that built it with us
- The handover is a meeting, the working repo, and the documentation your people wrote alongside us.
- A follow-up window that's optional
- Not contractual. If the kit is working, you do not need us. If something lands, we already know the system intimately.
The teams that get the most out of it.
Marketing, e-commerce, data and ops teams in SMEs who've decided to build something specific. The Build is at its best when there's already a clear answer to "what should we automate first". An AI Audit gets you to that answer, but you may have done the equivalent thinking with your own people. Either is fine. You don't need a technical lead in place already, though the engagement runs more smoothly when someone in the team is ready to be the AI owner after we leave.
The shape of the engagement.
We embed alongside your team for the agreed window. The five phases above are the rhythm. We work in your tools, on your data, with the people who'll keep using the kit afterwards. Sometimes that means the Shopify admin, sometimes a custom dashboard, sometimes Claude with the right MCP servers wired in. Whatever fits how your team already moves. By the end you own the kit, the people running it have built it with us, and the documentation isn't a slide deck. It's the working repo.
What the next conversation looks like.
A scoping call. We'll talk through what you're hoping to build, what your team looks like, and what the engagement window needs to cover. If you haven't done an AI Audit yet, we'll suggest starting there. It's the cleanest way to make sure we're building the right thing before The Build itself begins.