What is a scoped discovery?

A scoped discovery is a fixed-fee engagement that produces three things: a system architecture, a build plan broken into phases, and a running-cost model that includes model and infrastructure spend. The fee is fixed and quoted before you book. If you proceed with the build, it is credited toward it.

What do I own at the end of a discovery?

The documents. Architecture, build plan, and cost model are yours to keep, take to another engineer, or build in-house. That is deliberate. A discovery you cannot use without us would be a sales call with an invoice attached.

How are custom builds priced?

Project-priced, phase by phase, from the build plan the discovery produced. You approve each phase before it starts, so the number you see is tied to work that has already been scoped rather than to an hourly meter running in the background.

Who pays for the model and infrastructure costs?

You do, directly, on your own accounts wherever possible. AI systems have real per-use costs and marking them up quietly is how vendors turn a running system into a rent. The cost model in the discovery estimates that spend before you commit, and the systems we build are instrumented so you can watch it.

Is there a guarantee?

No, and we would be suspicious of one on custom work. A guarantee needs a fixed scope and a single measurable outcome; custom engineering has neither, so a guarantee attached to it is either unenforceable or priced into the quote. The fixed-fee discovery is the de-risking mechanism instead: a small, bounded commitment that tells you what the real one costs.

Do you work month to month?

Productized automation and white-label arrangements run on a monthly retainer; custom builds are project-priced and end when the system ships and is handed over. Every system we build is documented and handover-ready, so an ongoing retainer is a choice about who operates it, never a condition of keeping it running.

PRICING

Nobody can price your system before they've seen it.

So this page tells you how the money works instead of pretending a tier card can. Four pricing models, one entry point, and an explanation of what actually moves the number.

If you'd rather skip to it: the front door is a fixed-fee discovery, and the fee is credited toward the build.

THE FRONT DOOR

Everything starts with a scoped discovery.

A scoped discovery is a fixed-fee engagement that produces a system architecture, a phased build plan, and a running-cost model — before anyone writes production code. The fee is fixed and quoted up front, and if you go ahead with the build it comes off the build price.

It exists because the alternative is worse for both of us. Free scoping means the estimate gets made fast, on incomplete information, by someone motivated to win the deal. That estimate is wrong, and you find out which direction it was wrong in around week six.

A paid discovery buys the time to actually look: what you run today, where the data lives, what breaks when it's under load, and whether the thing you asked for is the thing you need. Sometimes the honest answer is that a $40/month tool already does it — and you'd rather hear that from the discovery than from the invoice.

What it produces

A system architecture, a build plan broken into approvable phases, and a cost model covering both build and running spend — model tokens, infrastructure, and third-party services.

What it costs

A fixed fee, quoted before you book. Not hourly, not a range that grows. If we can't scope it inside that fee, that's our problem to absorb, not yours to discover later.

What you keep

All of it. The documents are yours whether you hire us, hire someone else, or build it in-house. A discovery you can't use without us would just be a sales call with an invoice attached.

What it isn't

A proposal deck. There is no slide about our values. It's the same architecture document an engineer would write for themselves before starting, because that's what it is.

Book a Scoped Discovery →

HOW EACH KIND OF WORK IS PRICED

Four models, matched to four kinds of risk.

Different work carries risk in different places, so it can't all be priced the same way. Here's which model applies to what, and why.

Scoped discovery — fixed fee

The entry point for everything. One fee, one deliverable set, credited toward the build if you proceed. Priced fixed because the scope is genuinely fixed: we look, we design, we cost it out, we hand it over.

Custom builds & agent integrations — project-priced

Priced per phase from the discovery's build plan. You approve each phase before it starts. No hourly meter running in the background, and no single number quoted against a scope nobody has examined yet.

Productized automation — flat monthly

Repeatable systems, repeatable price. The agentic inbox is the clearest example: a known build, a known operating cost, a flat rate. Where the work is genuinely the same each time, custom pricing would be theater.

Agency white-label — monthly retainer

You sell it, we run the engine room. Retainer scaled to the number of client accounts under management, because that's what actually drives the operating load on our side.

The exact figures live in the discovery, not on a landing page.

Every published price we could put here would be a range wide enough to be useless, or a number narrow enough to be wrong. The discovery replaces both with an estimate built from your actual systems — which is the only kind worth quoting.

WHAT ACTUALLY MOVES THE NUMBER

Four things, in order of how much they matter.

How many systems have to talk to each other. One clean API is an afternoon. Four systems, two of which have no real API and one of which is somebody's spreadsheet, is the actual project. Integration surface drives cost more than anything else, and it's the thing most quotes underestimate.

What happens when it's wrong. An agent that drafts an internal summary needs far less engineering than one that touches a customer or moves money. Error handling, approval gates, and audit trails scale with consequence — and that's the work that separates a demo from a system.

Volume, because it sets the running cost. Model spend is per-use. A system handling forty items a day and one handling forty thousand are different architectures with different economics, and the second one needs the cheap-model routing designed in from the start rather than bolted on after the first invoice.

Who operates it afterward. Handing a documented system to your team costs less than operating it for you. Both are fine. But it's a decision to make at the start, because it changes what gets built — not a line item to negotiate at the end.

TERMS WE'LL STATE PLAINLY

The parts vendors usually leave for the contract.

Model costs are yours, unmarked up

Wherever possible the system runs on your API keys and your accounts, so you see the real spend. Quietly reselling tokens turns a system you own into a subscription you rent, and that's the problem we exist to fix.

You own the code

Documented, handover-ready, running on your infrastructure. You can operate it without us or hand it to another engineer at any point. Nothing is architected to be unmaintainable in our absence.

No guarantee, and here's why

A guarantee needs a fixed scope and one measurable outcome. Custom work has neither, so a guarantee bolted onto it is either unenforceable or already priced into the quote. The fixed-fee discovery is the real de-risking mechanism.

We turn work down

If an off-the-shelf tool solves it, or the engagement needs a team we don't have, we'll say so before you spend anything. Capacity is the honest tradeoff of a founder-led shop, and pretending otherwise is how projects go bad.

FAQ

Questions about the money.

Custom engineering has no list price because scope is the variable that sets cost. A number posted before anyone has seen your systems is a guess, and guesses get corrected upward mid-project. The discovery replaces the guess with an architecture and a real estimate before you commit to a build.

Three documents: a system architecture, a build plan broken into phases you can approve one at a time, and a cost model that includes model and infrastructure spend rather than only build hours. They're yours to keep — take them to another engineer or build it in-house if that's the better call.

Then that's the deliverable, and it's the most valuable outcome the fee can buy. We'd rather write "an existing tool does this for $40 a month" and lose the build than take a project we already know is the wrong shape. That answer has to be available for the discovery to be worth anything.

Project-priced, phase by phase, from the build plan. You approve each phase before it starts, so every number is attached to work that's already been scoped. If something changes mid-build, it gets re-scoped and re-quoted in the open rather than absorbed into a vague overage.

You do, directly, on your own accounts wherever the architecture allows it. AI systems have real per-use costs; marking them up quietly is how a system you paid to build becomes rent you pay forever. The discovery's cost model estimates that spend up front, and what we build is instrumented so you can watch it.

Productized automation and white-label arrangements run monthly. Custom builds are project-priced and end when the system ships and is handed over. Because everything is documented and handover-ready, an ongoing retainer is a decision about who operates the system — never a condition of it continuing to run.

Get the real number.

Tell us what you're running and what's breaking. If a discovery is the right next step, you'll get the fixed fee and what it covers in writing before you commit to anything.