What we build
The engineering behind our own products is available to clients. Same architecture rule, same standard of finish, whether the work ships under our name or yours. Four kinds of work, described honestly below — including who each one actually suits.
End-to-end engineering for multi-tenant software: architecture and data modelling, authentication and roles, billing and subscription logic, admin tooling, and the operational plumbing — logging, backups, deployment, monitoring — that decides whether a product is still maintainable in its third year. The unglamorous parts are designed in at the start, because retrofitting them is what turns a promising product into an expensive rewrite.
Who it suits: founders with a validated idea who want it built properly the first time, and established businesses turning an internal tool into a product other people pay for.
Agentic systems built on the split that defines how we work: AI plans, decomposes and drafts, then deterministic engines carry the plan out. That separation is what makes a result repeatable and auditable — you can see what was decided, and re-run it to the same outcome, instead of hoping the model behaves identically twice. It also keeps running costs predictable, because the expensive part runs once and the cheap part runs every time.
Who it suits: teams who built a promising LLM prototype and found it too unpredictable to put in front of customers.
Game design and development from concept through systems design to a released, running title: mechanics, economy and progression, the build pipeline, and the live operation a game needs once players arrive. Collection-oriented play is where our own interest sits, and Funnzoo is where that work goes — but the engineering approach is the same one applied to everything else here.
Who it suits: studios and publishers who want an engineering partner who will argue about systems design, not an outsourced pair of hands.
Custom software, systems integration, modernisation of software that has outlived its original architecture, and ongoing engineering support. This is the work that fits no product category: the internal tool nobody sells, the data pipeline holding a business together, the integration between two systems that were never meant to speak. Built to a standard you could hand to another engineer without apologising for it.
Who it suits: businesses in any market carrying software that works but can no longer be changed safely.
Plan, execute, verify
One rule decides the architecture of everything we ship, and it is the reason the work is predictable rather than merely fast.
Scope the work
We agree what is being built and what "done" means before a line of code exists.
AI plans
AI does the planning, decomposition and drafting — the part where breadth and speed matter.
Engines execute
Deterministic engines carry out the plan, so the same input always produces the same output.
Verify and ship
Every result is checked against the scope before release, then supported after it.
Tell us what you need built
Send a short description of what you need built. You will get a reply covering scope, approach and timeline — from the person who would do the work, not a sales desk.