Bring one job you do a lot.
Walk out owning the model that does it.
You are renting a giant AI model by the token to do a small, repetitive job. FallForge Mint turns a few of your own examples into a private model that does just that job — one you own, run on your own machine, and never pay per use again. Try it free below. Nothing to sign up for. Your examples never leave your browser.
Honest about what this is: your model is specialised — excellent at the one job you give it, not a general chatbot. That's the point, and it's why it can be small, private and cheap.
Dump your job in. Walk out with the right model, proven.
You don't need to know which model, or how big. That's the first thing this does for you — then it mints it, proves it on your own data, and hands you a signed receipt. All in your browser.
- Describe the job + your load. Pick the kind of work, the answer shape, how strict it must be and where it'll run. Size it below.
- Get the right open-weight model. You get the smallest model that should meet your bar — named, real, across the ladder from ~1B to ~200B — with the reasoning shown. Never an upsell.
- Mint it + prove it on your data. Turn a few real examples into a private model, then watch it try to beat the base on examples it never saw. It can say it lost.
- Own it, with a receipt. Download a one-file model you run locally — plus a signed, re-runnable scorecard (the trust rail) you can hand your CFO.
Which open-weight model do you actually need?
Everyone sells you the model or the hosting. Almost nobody tells you which size is enough. This does — biased to the smallest model that clears your bar (a 1B answer says 1B), with every factor shown. It's a starting point to mint and prove, not a benchmark.
Pick your job on the left and press Size my model. You'll get a named open-weight model, why that size, a second opinion to A/B, and a one-click hand-off to mint it.
Tell it the job. Show it a few examples. Get your model.
Type what you want the model to do, then paste a handful of real examples of the job done right. Press the button and you'll get a real model recipe you can run on your own computer. Everything happens in your browser.
Don't trust us — check the maths yourself.
When we mint a model for you, the result comes with a signed receipt that carries its own proof. Here's a real one from a model we minted, called review-1b. Press the buttons — the check runs in your browser, on the real signed record below.
That second line is the point: the receipt is allowed to say the model lost. A measurement you can't fail isn't a measurement. Renting a black box gives you no receipt at all.
◊ Someone sent you a scorecard? Check it's genuine.
If someone gives you a scorecard-….json from FallForge Mint, drop it here. This checks — entirely in your browser, nothing uploaded — that nobody changed the numbers since it was issued, and that its signature matches.
…or paste the JSON instead
◊ Re-run it in CI — a neutral machine, in the open
A scorecard proves nobody edited the numbers. The re-run rail goes one step further: a clean GitHub runner rebuilds the model from its recipe, runs every held-out example through the base model and the minted one again, and checks the result against the signed record. Anyone can run it. No account with us, and no need to trust us.
- Get the bundle. After Prove it, download the signed scorecard, then Download re-run bundle. It holds the receipt, the recipe and the held-out rows.
- Make your own copy of the runner. Open fallforgemint-rerun, press Use this template, and add your bundle to it (e.g.
bundle.json). Or fork fallforgemint itself. - Run it. Actions → rerun → Run workflow, with your bundle's path. It installs Ollama on the runner, rebuilds the model, re-runs the held-out set and grades it.
- Send the run link. The run's summary shows the verdict, and its artifact holds a self-hashed attestation bound to that run's address. The link is the proof.
Proven both ways, on real runs: the proof runs are linked here once they have run.
What it shows, and what it doesn't: every recorded number is recomputed from the bundle, and the held-out set is run again on that runner. It does not attest the machine that made the original, and it says nothing about what the base model saw in its own training. A scorecard made in your browser is re-run on Ollama's build of the same model (qwen2.5:0.5b) — a different runtime and quantisation — so its test is AGREES, not an exact match.
Own vs rent — see which actually wins for you.
Owning isn't always cheaper, and we won't pretend it is. Put your real numbers in and this tells you the truth — including when you should just keep renting.
Opt-in and conservative: recycling only lowers the run cost on the repeating share of your work. On all-unique work it saves nothing — leave it off.
What you walk away with — and what it plugs into.
The honest, full list. live is real on this page today; next is on the roadmap and marked as such. No magic, no "full estate power" hand-waving.
- live A sized recommendation: the smallest open-weight model that meets your bar, named, with the reasoning shown
- live A private Modelfile minted from your own examples — deterministic, reproducible
- live A one-click installer (Mac/Windows/Linux) — own it in a double-click
- live A live in-browser preview — try it before you install anything
- live Runs on your machine, offline. No account, no per-token bill
- live A signed scorecard — tamper-evident, re-hash to check nobody edited the numbers
- live keyClass stated honestly: a browser key proves the numbers are unedited, not who ran the eval
- live Held-out, hash-disjoint: the held-out answers are provably not in the spec the model was given (narrow-true, few-shot)
- live Re-run in your browser — the eval is deterministic; anyone can reproduce the scores
- live Re-run in CI — download a re-run bundle and a clean GitHub runner rebuilds the model, re-runs the held-out set and checks it against the signed record; a mismatch fails the job. How
- live An own-vs-rent calculator that says keep renting when that's genuinely cheaper
Owning your model is the door into a sovereign stack. These are separate products — open each directly at the address shown; confirm the current status there.
- Run it — hatch a private assistant around your models in fall-os (fallworld / the live estate surface)
- Federate it — real peer-to-peer, no server in the middle (meshos / fallroom)
- Address it — route jobs to the right model with no silent gaps (capability-router / the dispatcher)
- Verify others' live — drop any FallForge scorecard in the Proof section to check it's genuine
Honest scope: this page ships the model + the trust rail. The estate products above are the on-ramp, not bundled here — treat "full estate power" as the sovereign stack you can grow into, stated straight.
Start free. Or have us do it for you.
You can build and own a model here for nothing. If you'd rather we did the work — and proved it — we can do that too.
Everything on this page, forever.
- Build your Modelfile above
- Preview it live in your browser
- Download it and own it outright
- No account, no per-token bill
We do the work and prove it beats your baseline with a signed receipt.
- We mint, tune and prove one owned node
- Weight-level tuning where it helps
- A signed receipt — the proof it works
- Set up private on your machine
- You own it outright, no per-token bill
We keep it sharp as your work changes.
- We host, watch and re-mint your nodes
- Add new nodes as new jobs appear
- Nodes that cross-check each other
- Your own private AI stack, maintained
Not on the menu: anything regulated — legal advice, tax, medical or financial products. Those need proper professional sign-off first, and we won't pretend otherwise. This is for the everyday, high-volume, unregulated work you're overpaying to rent.
What's actually happening here.
No jargon. Here is the whole journey, start to finish.
- You describe one job. Something you currently ask a big AI to do over and over — sorting messages, pulling facts out of text, tagging things, drafting the same kind of reply.
- The sizer picks the right model. From the kind of work, the answer shape, how strict it must be and where it'll run, it recommends the smallest open-weight model that should clear your bar — from ~1B up to ~200B — and shows exactly why. It never rounds up to sell you a bigger one.
- You show it a few examples. Three to eight is plenty. Each one is an input and the answer you'd want back. This is how the model learns your exact style.
- Your browser builds a recipe. Right here, with nothing sent anywhere, it writes a Modelfile — a short, plain recipe that bakes your job and your examples into a small model.
- It proves itself on data it never saw. It holds out some of your examples, runs both the base model and yours on them, and scores them. You get a signed scorecard with the honest small print: what the signature proves (the numbers are unedited), that the held-out answers were not in the spec the model was given (hash-disjoint), and that anyone can re-run the eval. It's allowed to say your model lost.
- You run two lines to make it yours. You install a free app called Ollama, and paste the two lines we give you. Now a private model that does your job lives on your own computer — no monthly bill, no per-use charge, working with the internet switched off.
- If you'd rather not touch any of that, we'll do it for you and prove the result beats your starting point with an issuer-signed receipt.
The things people ask.
Do I really own the model?
Yes. The mint produces a Modelfile — a plain text recipe — that you run on your own machine with a free tool called Ollama. The resulting model lives on your computer. There's no account, no per-token bill, and it keeps working with your internet off.
Do I need to be technical?
No. You paste your task and a few examples and press one button. To run the model yourself you install a free app and paste two lines we give you, step by step. If you'd rather not, we can set it up for you.
Is my data safe?
Yes. Everything on this page runs inside your own browser. Your task and examples are never sent to us or anyone else. The model you build runs on your machine.
What's the catch with owning instead of renting?
A small owned model is cheaper and private, but it's specialised — brilliant at the one job you trained it on, not a general chatbot. For a narrow, repetitive, high-volume task that's exactly what you want. The calculator above shows, honestly, when renting is actually the better deal.
How do I know it's any good?
Every minted node is measured against its starting point by a deterministic gate, and the result is written into a signed receipt that can — and sometimes does — say it lost. You can re-check that proof yourself in your browser, in the Proof section above. Nobody renting you a black box can offer that.
What does it cost?
Building and downloading your Modelfile here is free — you own it, with no account and no per-token bill. If you'd rather we set it up and proved it for you, that's a service we offer too.
One job you do a lot. I'll mint you a proof node, free.
Tell me the repetitive thing you feed an AI most. I'll build you an owned model for it and send you the signed receipt. If it's good, we talk. If it isn't, you've lost nothing and I'll say so plainly.