Custom AI System Implementation
We build a complete AI system for your business, deploy it to your infrastructure, train your team, and hand off MIT-licensed source code committed to your repo. Fixed scope, fixed price, 30 days of post-launch tuning included. You own everything. Fork, modify, or take it in-house anytime.
What you get
Included
- • Implementation against agreed scope
- • Deployment to your infrastructure (or jointly-chosen hosting)
- • Source code in your repo, MIT-licensed where applicable
- • Architecture documentation
- • Operational runbook (deploy, monitor, recover, scale)
- • Team training, 1–2 sessions sized to your engineering org
- • 30 days of post-launch tuning and bug fixes
Not included
- • Ongoing operation after the 30-day window (handled as a separate custom engagement when needed)
- • LLM API costs (you own those accounts directly; pass-through with no markup)
- • Infrastructure / hosting costs (your accounts, your billing)
- • Major scope additions mid-engagement (handled as a separate priced change order)
How an implementation engagement works
- 01
First conversation (free)
30–45 min. We learn the problem; you learn if we're a fit. No pressure.
- 02
Advisory session (required, paid hourly)
We define the problem, sketch the solution, surface trade-offs, decide if Implementation is the right next step. You leave with a written deliverable regardless of whether Implementation follows.
- 03
Statement of work + quote
Fixed scope, fixed price, fixed timeline. Signed before any build work begins. No 'discovery as we go.'
- 04
Build (1–8 weeks, typical 3–6)
Senior practitioner builds the system. Progress reviews on a schedule that fits how your team operates.
- 05
Handoff
Code merged to your repo. Architecture doc + runbook delivered. Team training (1–2 sessions). You have everything needed to operate it.
- 06
30 days post-launch
Included tuning and bug fixes against the agreed scope. Fast-response support; we stay close.
- 07
Ongoing (optional)
Additional implementation engagements, advisory retainer, or fully self-operated. Whichever fits.
Pricing
$25,000 – $75,000, scoped after a paid advisory session that defines the work.
Single fixed price stated upfront. Third-party costs (LLM APIs, telephony minutes, hosting) are pass-through and clearly labeled — you own those accounts and pay the upstream provider directly, no markup from us. Engagements above the upper bound are custom and require a conversation to scope.
FAQ
Why do I have to do an advisory session before Implementation?
Because Implementation pricing depends on a defined scope, and an honest scope only emerges from a real conversation. The advisory session is how we figure out what to build, what trade-offs you're making, and what's realistically deliverable in the budget. Without it, we'd be quoting blind — and blind quotes are how clients end up overpaying for the wrong thing.
What does 'in your repo' actually mean?
Code is committed to a repository you own — GitHub, GitLab, BitBucket, whatever. You own the GitHub org, the access controls, the merge rights. We push to a branch we control during build, then merge to main when you sign off. No private fork on our side, no escrow, no licensing key that revokes your access. You can fork it tomorrow and we can't stop you — that's the design.
What if I want REAA packages but my engineers will modify them?
Fine. The platform is MIT-licensed. Fork any REAA package, modify it, vendor it into your repo. We'll note the divergence in the runbook so future maintenance is informed.
What's the timeline for a typical engagement?
1–8 weeks of build time depending on scope. Most engagements land at 3–6 weeks. Permission-gated work (where third-party access has to be granted) can extend that by whatever the third party's process requires.
Can I split a $75k engagement into phases?
Yes. Larger engagements are often best as phase-1-MVP / phase-2-extension with separate SOWs. Each phase is its own scoped engagement with its own price; you commit to phase 2 only if phase 1 lands well.
What happens after 30 days?
The post-launch window covers tuning and bug fixes against the agreed scope. After that, if you want help adding features, that's a new engagement (Implementation or Advisory, your call). If you want us to operate the system for you, that's a separate custom engagement at the hourly rate. Most clients self-operate after handoff.
What about scope changes mid-build?
Handled as a priced change order — written, signed, additive to the SOW. We never open-endedly add work without a price; that's how clients get surprised. The first conversation about a change is free; if it lands as a real change, we quote it.
Do you only build with REAA packages?
No. REAA is the platform we know best and the foundation for most builds, but if your needs are better served by a third-party package or framework, we use it. The goal is the right system for your business, not maximizing REAA usage.
Have a real AI system to build?
First conversation is free, 30–45 minutes. We'll figure out whether we're a fit before either of us commits.