Foundry trains a domain model inside your perimeter and hands you weights you own outright. You do not need a corpus to start: a few hundred real examples is enough, and we build the rest. Start with a one week audit that will tell you whether you need a model at all.
One week corpus audit first, free while we build our first references
full builds $15k to $120k
no corpus required to start
air-gap capable
Every open checkpoint was trained on public web text. It has never seen your taxonomy, your regulatory vocabulary or your document formats. Running it on your own GPUs makes it private. It does not make it good at your job.
Foundry closes the gap: a model that knows your domain, serving on hardware you own, with the weights in your hands and no licence attached to them.
Jargon, regulatory language and document formats that public web text never covered.
A frontier API on a repeated narrow task is the most expensive option. A small model trained for it costs a fraction, on hardware you own.
If hosted fine-tuning is closed to you for the same reasons as hosted inference, this is the path left.
Most teams think they don't have enough data. Usually they mean volume, and we can solve for volume.
Your documents, tickets, filings, logs or code. We check duplication, PII, balance and template collapse first, and tell you in writing if it is too thin to build on. The cheapest path, with the least risk.
How most projects start. About 500 real cases define the domain, and we expand them synthetically into training volume that stays within their distribution. Every rung is available this way.
We curate a licence-filtered corpus from public sources and build against an eval suite agreed with you up front. It is how we trained our finance model on Hugging Face.
Your path sets the token budget and the timeline, and the audit week settles it. Delivery is the same either way.
Synthetic data is decontaminated against the eval suite, so the scores at the end still mean something.
# seed set you actually handed us seed examples 412 real deduplicated 397 quality filtered 361 # volume we generate from it synthetic expansion 361 → 84,000 grounded in seed distribution eval contamination clean # corpus we curate, when you have none public domain crawl 11.4B tokens licence filtered 8.9B total corpus 9.1B tokens # your 412 examples set the target. # they are not the training set.
Three rungs. Picking the right one usually saves you money.
Instruction tuning or LoRA on an open-weights base. Delivered as safetensors and GGUF, deployable on your existing vLLM or Ollama setup.
Corpus construction, continued pretraining on an open base, then post-training. Most of the value of a from-scratch build at a fraction of the cost, and the right answer for most teams who ask for rung 3.
Tokenizer design, corpus pipeline, architecture selection, pretraining, post-training, eval harness, technical report.
The clock starts at data access, not at signature. Training is rarely the long pole: a 9B model over 122B tokens is days on the right pod, and we shorten it with compute, never by cutting evaluation. Corpus readiness moves the date.
A bad config burns the compute. We check everything that can't be undone before a GPU hour is spent.
One week, free while we build our first references. We audit your data, measure tokenizer fit and train small models on your corpus to see where the curve goes. You get a written report either way, and roughly half conclude that retrieval or a fine-tune is enough.
The corpus is a versioned pipeline with lineage, verified PII redaction and checked balance. Configuration checks block the mistakes that cost us three models, and training records a second curve, because this failure never shows in the loss.
We open the weights up (dead embedding rows, layer contribution, special-token health) and smoke-test them on your serving stack. Eval targets on your held-out ground truth are agreed in writing first. If the weights miss them, the remediation is ours.
Safetensors and GGUF, the eval harness and the configs to reproduce the run. Serve them on your own vLLM or Ollama. The engagement ends there.
# checked before a single GPU hour is billed P1 weight decay excludes norm gains BLOCK exclusion list is empty: every parameter decays, including the RMSNorm gains. invisible in loss. P2 checkpoint interval fits tenure BLOCK 10000 steps on spot capacity: every preemption restarts at zero P15 licence permits delivery terms pass P16 eval sets decontaminated pass P17 tokenizer fertility measured warn # 2 blocking. run not started.
Billing is by milestone: 30% on corpus delivery, 30% at the mid-training checkpoint with evaluation, 40% on final delivery. Compute is passed through at cost plus 15% and billed separately.
Built for isolated networks, but not limited to them. Where it runs is a compliance decision, not a product tier.
Offline install from mirrored images, training on isolated hardware, delivery on physical media. No licence server, telemetry or callbacks: your firewall rules are the control. Read the security page →
On your cluster or cloud account, against storage you control, with our engineers driving. For when residency rules bind the data but the network is not sealed. We bill engineering time only.
No compliance boundary? Then you do not pay for one. You bring the domain, we bring the compute and the training stack, passed through at cost plus 15%.
Delivery is identical everywhere: safetensors and GGUF, the eval harness, the corpus pipeline and the training configuration, owned outright.
Most custom-model vendors run someone else’s fine-tuning API behind a project plan. We pretrained a 9B mixture-of-experts model from scratch on 122 billion tokens (TPU v6e, MaxText and JAX): tokenizer, corpus pipeline, architecture, training loop and evaluation.
The technical report is public, including where the model underperforms and what we would do differently. Ask the same of anyone you let near your training data.
Safetensors and GGUF, the eval harness and the configs. No per-seat AI tax and no renewal date.
Local inference, offline licence validation, your own SMTP and storage. Block us at the perimeter and it keeps working.
Built in the 9B class, sparse where it helps, so it serves on the GPUs already in your rack.
A model engineer reads every one of these and replies in writing, usually within two working days. No sequence, no nurture track.
Prefer email? Write to contact@thinkingdbx.com. If your question is really "which rung do I need", the audit week answers it faster.
Bring the task and whatever data you have. We'll tell you which rung you need, including when the answer is don't build.
Or email contact@thinkingdbx.com.
safetensors and GGUF, owned outright, no licence to renew.
Built on your ground truth, so you can re-run it on every future version.
Versioned, contract enforced, with lineage from source rows to model version.
The exact configs and report, so another team could reproduce the run.