Most of your business already lives in a project chat with your own model — it has learned your operation. Our Client Intake Protocol drops into that project, harvests what the model holds, interviews you to fill the gaps, and digests it into a spec bundle you read line by line. We build it verbatim.
↳ copies + downloads a .md · costs nothing · runs in your own project
It costs nothing and runs on infrastructure you already trust — your model, your account.
Your rules never leave your account until you send the bundle. Nothing to sign first.
You read exactly what we will build before we touch a line of it.
Three honest steps. No black-box magic — the protocol is plain text you can read, the bundle is plain text you approve.
Paste the protocol into the chat where your model already knows your business. It reads what is there, then asks one question at a time — never guessing, re-asking when you are vague.
When no new rules surface, it digests everything into one spec bundle — DOMAIN · ENTITIES · RULES · EXCEPTIONS · GLOSSARY. You inspect it line by line, then send it.
The factory builds to the bundle and nothing else. Stone Law: nothing ships until a human says so. What you read is what you get.
↳ the protocol, exactly as it runs. the download equals this byte-for-byte.
↳ a real bundle, names scrubbed. input on the left, output on the right.
Our edge is not "we use AI." It is a measured, multi-agent engineering machine — separation of duties, contract-first testing, adversarial design, machine-enforced gates.
The agent that writes the tests is not the one that writes the code — and the builder cannot edit the tests. Contracts are frozen before a line is written, so passing means the work is right, not that the goalposts moved.
Three scouts take different lenses on the same ticket, then a synthesis takes the best of each. You get three experts' best, not one model's first guess. Disagreement is the feature.
You bring your own key. Each run is metered against a cap you set, and the receipt is honest — per stage, per agent, per token. Consultancy is quoted on project size — book a scope call.
One gate, and what runs on your laptop is exactly what runs in CI. Quality thresholds only move up, never down — and each check is itself tested against known-bad code, so the gate that guards the work is guarded too.
The system, your brand, and your data live in your source control and your infrastructure. We hand over the keys, not a tenancy.
We train your people to run the agent squad without us. You leave with the ability to ship again — a team, not a retainer you can't cancel.
Managed, plainly: we keep the line warm — monitoring, dependency upkeep, and new batches on a cadence you set. It is opt-in, and you can take the wheel any day.
The engine is open source — bonfire-ai on PyPI. You don't need our workshop; you need your car running. The escape hatch is built in.
Their quoting and approval ran on a rented SaaS that owned their data and their roadmap. We intook the operation, froze the rules, and rebuilt it as owned infrastructure in their own repo — same workflow, no monthly tenancy, no export wall.
A shared CRM with a WhatsApp qualifier bot across several sister companies — intook once, built to the bundle, handed to a team that now runs it themselves.
Cases are concrete-anonymized until cleared. The engine is third-party-checkable: GitHub ↗ · PyPI ↗
Get the Intake Protocol — copy it or download the .md.
Run it in the project where your model already knows your business.
Send the bundle — or book a scope call to walk through it together.