DUC
Stop duct-taping prompts.
Ship a model that sticks.
Ductape turns your brittle prompt stack into a small, fast, fine-tuned model — trained on your data, speaking in your voice, running on your terms. Same behavior, every single time.
30 minutes · real numbers on your use case · no deck, no fluff
A 4,000-token system prompt is not a strategy. It's tape.
- ✗You've tried mega-prompts, few-shot stuffing, and chain-of-thought incantations. It works… until Tuesday, when it doesn't.
- ✗Every edge case becomes another patch: "NEVER apologize twice", "ALWAYS return valid JSON", "STOP saying as-an-AI".
- ✗You're paying frontier-API prices to re-explain your business in every single request — thousands of times a day.
- ✗One provider model update, and your carefully tuned behavior shifts overnight. Nobody signed off on that.
There's a name for baking behavior into the weights instead of begging for it in the prompt. It's called fine-tuning — and it's the only thing we do. Your rules stop being suggestions and become how the model thinks.
Watch the tape come off.
One prompt. On the left, a frontier API doing its best with your mega-prompt. On the right, an 8B model we fine-tuned on your data. Pick a scenario:
Illustrative outputs — in a real engagement, the demo runs on your tickets, your schema, your jargon.
When behavior lives in the weights, everything gets lighter.
Your API bill collapses
A tuned 8B model does the job you're renting a frontier model for — so each call costs cents-per-million instead of dollars. The mega-prompt tax disappears too.
01Responses in milliseconds
Small models on dedicated serving are fast — no 3-second spinner while a giant model re-reads your 4,000-token constitution.
02The same answer twice
Trained behavior doesn't drift with prompt phrasing or provider updates. Your format holds, your tone holds, your rules hold — measurably.
03You own the weights
The model is yours — an asset on your side of the fence, not a dependency on someone's roadmap. Take it to any cloud, or run it in your own racks.
04Data stays home
Train and serve inside your VPC or on-prem. Customer data stops commuting to third-party APIs — your security team finally exhales.
05Proof, not vibes
Every engagement ships with an eval harness built on your success criteria. You see base-vs-tuned scores before you deploy — and drift alarms after.
06Feel the loss go down.
This is the dial-turning we obsess over so you don't have to. Set up a pretend run — data, epochs, learning rate — and watch what it does to the training curve and your unit economics.
Simulated numbers for intuition — your real curve gets built on your real data. We'll show you live ↴
Four steps. About four weeks. Zero mystery.
Model audit
We tear down your current setup — prompts, costs, failure logs — and tell you honestly whether fine-tuning wins. If it doesn't, we say so and you keep the audit.
Week 1 · freeData engine
Your tickets, docs, and best outputs become a curated training set. We dedupe, filter, and fill the gaps with reviewed synthetic examples. Garbage never gets in.
Week 2Train & evaluate
We tune candidate models and score every one against an eval suite built on your definition of good. You see base-vs-tuned numbers, not vibes.
Weeks 3–4Deploy & drift-watch
Your model ships to your cloud, your VPC, or ours — with monitoring that catches drift before your users do. Retraining is a pipeline, not a project.
OngoingTeams that cut the tape — and the bill.
"We replaced a 3,500-token prompt on a frontier API with a tuned 8B model. Costs dropped 91% and format errors went from daily to — honestly, I can't remember the last one."
"The audit alone paid for itself. They showed us two use cases where fine-tuning wasn't the answer and one where it obviously was. That honesty bought a lot of trust."
"Our support bot finally sounds like us — not like a press release apologizing to itself. CSAT up 14 points since the tuned model shipped."
"Compliance wouldn't let customer data leave our VPC, which killed every API-based plan. Ductape trained and deployed entirely inside our perimeter. Unblocked a year-old roadmap item in five weeks."
"p95 latency went from 4.1s to 380ms. Our agents stopped alt-tabbing while they wait. That alone was worth it."
"The eval harness is the real product. We now have a number for 'is the model good' and a graph when it isn't. Every retrain is a pull request, not a panic."
Scoped like engineering, not like consulting.
Fixed scope, fixed price, and a guarantee with teeth.
One use case, end to end. Prove it works before you commit.
- Model audit & baseline evals
- Data curation (up to 10k examples)
- One fine-tuned model, one revision
- Eval report: base vs tuned, on your criteria
- Deploy to your cloud or ours
A model your product depends on — hardened, monitored, yours.
- Everything in Pilot
- Full data engine + synthetic augmentation
- Multi-candidate training (SFT → DPO)
- Serving setup: vLLM, autoscaling, p95 targets
- Drift monitoring & alerting
- Handover docs + team training
We run your model program: many use cases, continuous retraining.
- Dedicated tuning pod
- Quarterly model refreshes
- New use-case discovery sprints
- 24h eval-regression response
- Priority GPU capacity
The baseline guarantee
If our fine-tuned model doesn't beat your current setup on your own eval suite — the one we agree on in week one — you don't pay the final milestone. In the contract, in writing.
The questions everyone asks before cutting the tape.
Less than you fear. 500–5,000 good examples often beat 50,000 sloppy ones — and most companies are already sitting on them: resolved tickets, approved copy, reviewed outputs. Our data engine turns that raw material into a training set, and fills genuine gaps with human-reviewed synthetic data.
Different tools, often used together. RAG gives a model things to know; fine-tuning changes how it behaves — tone, format, judgment, domain reflexes. If your problem is "it can't find the answer", you want retrieval. If it's "it keeps answering wrong", that's us. Many builds ship as a tuned model with a retrieval layer.
Open-weight families first — Llama, Mistral, Qwen, Gemma — because you get to own the result. Where a hosted fine-tune endpoint genuinely fits better, we'll use it and tell you why. Model choice is a deliverable of the audit, not a default.
Your data trains your model and nothing else. We work under DPA, train inside your VPC or on isolated infrastructure, and delete working copies after handover. For regulated teams we run fully on-prem — your data never crosses your perimeter.
A pilot goes from kickoff to a deployable, evaluated model in about four weeks. Production hardening adds two to three more, mostly around serving, monitoring, and handover. The audit itself takes one week and tells you the real number for your case.
That's what the drift-watch is for. Your eval suite runs continuously against production traffic samples; if scores slip, you get an alert and we get to work. Because the whole pipeline is automated, a retrain is a routine, not a rescue mission.
The opposite — your prompt stack is a goldmine. Every rule, example, and edge-case patch in it is a labeled specification of how you want the model to behave. We convert exactly that into training data. Your prompt engineering becomes the curriculum; the weights become the graduate.
Ship the model your prompt was pretending to be.
Tell us what you're building. Within one business day you'll get real numbers — cost, latency, quality — on what a fine-tune would change. If it's not worth it, we'll say that too.
You're on the bench schedule.
We'll reply from [email protected] within one business day with a few slot options for your audit call.