The Build
A working agentic team, built to one standard: every output it shows you has been verified against reality before you see it.
Scope, price, and timeline in writing before anything is built. From $4,500. Built and delivered remotely, wherever your business is.
What the Build actually is
A small specialist team of agents that performs the specific operational work the Diagnostic identified as your bottleneck — built around your rules, captured in your words, and applied the way you would apply them. The system is configured to your operation, not to a generic template.
The Build is not software you have to learn. It's not a SaaS subscription you maintain. It's a working operating layer that performs the work that currently requires you. And it fails honestly: when the system can't verify something, it says so — it does not guess. A confident wrong answer is the one defect we do not ship.
Two kinds of builds
The Diagnostic tells us which one your bottleneck needs.
The Operating Layer build — most builds.
An agentic team plus a knowledge base, running on top of the tools your business already uses. Research, writing, review, coordination, judgment work. Built and delivered remotely. Faster and lighter, because there's nothing hostile to integrate — the work is encoding your judgment, not breaking into anything.
The Deep Integration build — some bottlenecks demand it.
The system must work against other people's systems: credentialed platforms your business logs into, data that lives behind logins, infrastructure you need to own. These builds run longer — quoted in weeks, including acceptance testing — carry a higher floor, and come with one honest warning we give per platform: third-party platforms have terms, bot detection, and moods. If a platform ever pushes back, our playbook is disclosure and a request for sanctioned access — not evasion. We've been through it once; the account was reinstated and the integration got safer. On-site work is available for these builds where geography allows, or anywhere when deployment costs are covered — but it's an option, not a requirement.
Either way, the timeline isn't a slogan on a website. It's a line in your promise letter, quoted against your actual scope, before you commit.
Five disciplines, every build
1. The reality check.
Before anything is scoped, we verify what your data and tools actually look like — not what the brochures say. Exports, screen shares, real records. If the honest answer at this stage is "don't build this," we say that instead.
2. The promise in writing.
You get a one-page letter, in plain language, describing exactly what the system will do, what it will never do, what it costs, and how long it will take. Nothing gets built on an interpretation. When something you'll see is ambiguous, we show you a mock with real numbers and get your approval before building it.
3. Riskiest first, verified always.
The riskiest piece gets built first and proven against the real world before anything depends on it. Every change is tested offline, then live, then against real end-to-end work — in that order, every time. Where credentials are involved, they're typed by you, on infrastructure you control. They never pass through us.
4. Acceptance under real use.
The system isn't done when we say it works. It's done when your real work has tested it. For an Operating Layer build, that means you reviewing real output cycles until they meet your standard. For a Deep Integration build, it means your staff using the system at full scale and reporting everything that looks wrong — on our first such build, the client's team surfaced about fifteen real issues in two weeks, and every one was fixed as it was reported. Your team finding issues is not the process failing. It is the process working — it's how your expertise enters the system.
5. Reconciliation, in writing.
At close, we audit the promise letter against the delivered system, line by line, with you. Anything promised and not built gets an explicit decision — built next, re-scoped, or retired — never silence. Anything built beyond the promise gets named. You end the Build knowing exactly what you have.
What you own after the Build
Everything.
The system, wherever it runs — your accounts, your infrastructure, or a machine you own. The code, in a private repository you can be given. Your credentials, which never left your hands. The operational documentation: how to run it, update it, restore it, and what to do when something looks wrong. The test suites that verify it. And the trained ability — yours or your designated operator's — to run it without us.
If you choose to stop working with DeBottleneck the day after handoff, you keep what was built and you can continue to operate it on your own. With a subscription, the value depends on your continued payment — when you stop, the system stops. With a Build, the system is yours, whether you continue working with DeBottleneck or not.
What the proof looks like
The Operating Layer archetype, proven on our own business. The operator's own three-agent team has been in production for over a year, writing his weekly newsletter to 18,548 subscribers, at a 41% average open rate. It hasn't missed a week. The agents handle research, drafting, and editorial review against a knowledge base that gets updated when the audience or the standards change. It improves month over month because of how it's structured, not because anyone is babysitting it.
The Deep Integration archetype, proven on a paying client. A three-location independent pharmacy whose owner was doing her suppliers' price comparisons by hand. Diagnostic, written promise, build, live delivery, two weeks of her staff testing it on real work, and a written reconciliation at close. Delivered, accepted, and paid in full. Read the case study →
Your operation isn't a newsletter and it isn't a pharmacy, and your bottleneck isn't the same. That's the point of the Diagnostic: the methodology holds; what it builds is yours.
Pricing and scope
Builds start at $4,500. Deep Integration builds price higher — our first closed at $5,500. Final pricing is scoped after the Diagnostic, against the complexity of the bottleneck, the systems the build must work with, and the standards the agents must meet. Half is paid to start the Build; the balance at delivery. There is no monthly fee tied to the Build itself.
If the scope grows mid-build — it happens; our first Deep Integration build grew from two supplier integrations to five — that expansion gets a deliberate decision, made with you, out loud: included as goodwill, or scoped and priced. Silence is the only option we don't allow ourselves.
What happens after handoff depends on you. Phase 3 exists because some systems drift — if you want someone keeping the system aligned with the standards we set in the Build, that's what Phase 3 is. Phase 3 is optional and decided separately.
How you get to a Build
The only path into a Build is through a Bottleneck Diagnostic. There's no shortcut, and there isn't supposed to be one.
The reason is structural. A Build can't be scoped without a Diagnostic, because the Diagnostic is what names the bottleneck the Build addresses. An agent team built on a wrong diagnosis is a worse outcome for everyone — for you, because you paid for the wrong build, and for DeBottleneck, because the methodology gets its credibility from working, not from selling.
If the Diagnostic says agentic systems are the right fit, the next step is the reality check and your promise letter — the exact scope, price, and timeline, in writing, before anything is built. You can accept it, negotiate it, walk away from it, or sit with it. No deadline, no pressure.