AI Systems
That Ship.
Fixed price · 2–6 weeks · Code you own
Six shapes of AI system.
One-page spec, fixed price, weekly demos. Pick a shape or book a call and we'll find the right fit.
AI copilots.
Chat interfaces with tool-use, wired into the systems your team already runs. They read your data, draft the work, hand it back.
RAG pipelines.
Retrieval that survives production. Eval harness from day one, so answers stay grounded when the corpus changes.
Agent systems.
Tool-use loops with guardrails, human-in-the-loop checkpoints, and evals that catch drift before your users do.
Voice & realtime.
Low-latency voice agents for intake, dispatch, and field use. Built for noisy rooms, not demo stages.
Workflow automation.
Job runners, schedulers, and event-driven pipelines that move work through your stack without a human in every loop.
MCP integrations.
Model-Context-Protocol bridges that let Claude reach into the tools your team already uses — typed, audited, revocable.
From call to shipped code.
Four steps between the first conversation and working software in your repo.
30-minute call.
We map the problem together. You tell us what you need. We tell you which shape fits — or why none of them do. No pitch deck, no pre-sales motion.
One-page spec.
Within 48 hours you get a one-page document: fixed scope, fixed price, fixed timeline. You sign it over plain email. No legal circus, no statements of work the size of a novel.
Weekly Friday demos.
Every Friday you see the thing running. Not a slide deck — a working system. Changes outside the spec go in a change order. You're never surprised.
Full handoff.
Repo, keys, prompts, evals, runbook. In your org from day one. We delete our access after handoff. Thirty days of free bugfix included, no retainer required.
What ships with us.
Every engagement ends with the same three guarantees — regardless of shape.
Working code.
Not a prototype. A system that runs in your environment, handles your actual load, and ships on the date in the spec.
Evals + runbook.
A test suite that catches drift before your users do, plus plain-language docs on how to operate, update, and scale it.
Full ownership.
Your repo, your keys, your prompts. We delete our access after handoff. 30-day bugfix included. No retainer, no lock-in.
Writing from the field.
Short notes on what we've learned building production AI systems.
Why evals before demos.
Every demo-first project we've seen fails the same way. The demo impresses, the handoff lands, and then the first corpus update breaks it quietly. Evals are the thing that makes weekly demos honest.
The spec that fits on one page.
If you can't describe the system in one page, you're either describing two systems or you haven't decided what it is yet. The constraint is a filter — it catches scope creep before it costs money.
Claude tool-use in prod.
Six patterns we use on every copilot and agent engagement: rate limiting, audit logging, allow-listed tool schemas, human escalation paths, timeout budgets, and output schema enforcement.
Who this is for.
We're a small team. We take a small number of engagements at once. That means we get to be honest about fit.
You are —
- A team with a real problem and real users, not a proof-of-concept for a pitch deck.
- Looking to ship something in weeks, not months — and okay with a fixed scope to get there.
- Technical enough to review a repo, even if you don't write the code yourself.
- Interested in owning the system after we hand it off, not renting it from us.
You are not —
- Looking for a retainer or ongoing managed service — we hand off and step back.
- Expecting a large team: this is a small studio, not an agency with pods and layers.
- Wanting to replace a human workforce with AI — we build tools that augment, not supplant.
- Unwilling to define scope before we start — the one-page spec is non-negotiable.
Straight answers.
How is this different from hiring an agency?
Agencies deliver slideware, timelines, and change orders. We deliver working code in your repo, weekly demos, and fixed scope. Our typical engagement is one engineer shipping one system in 2–6 weeks — not a pod of ten people billing hours against a retainer.
What does a typical engagement look like?
A 30-minute discovery call, a one-page spec, a fixed price, and then 2–6 weeks of weekly Friday demos where you see the thing work. At handover you get the repo, the keys, a runbook, and 30 days of free bugfix.
Who owns the code?
You do, from day one. We work directly in your GitHub org on a branch you can review. When we hand over we transfer ownership and delete our access. No IP holdback, no platform lock-in, no monthly fee.
How much does it cost?
Fixed price per engagement, scoped to the one-page spec. Most engagements land between $15k and $60k depending on scope and complexity. We tell you the number before you commit to anything.
What if the spec changes mid-build?
Changes outside the original scope go in a change order — a short addendum with a price and timeline. We don't absorb scope creep silently and we don't surprise you with invoices. Everything is written down.
Do I need to know anything about Claude or LLMs?
No. You need to know your problem and your data. We handle the model engineering. We do ask that you have a real use case and real users — we don't build proofs of concept for pitch decks.
Book a call.
30 minutes. We'll tell you if we can help — or point you to someone who can.