Behind PackOS is PackOS Labs — the packaging-model company. Four specialist models: one reads artwork the way an engineer does, one exists only to argue with the others, one builds production structure, and one commits to a price — trained on production ground truth and shipped inside a quote flow you can run today. Less, deliberately: each model owns one craft completely.
4Specialist models
3Tiers — see · make · decide
500+ file ground-truth corpus
3,500+ records cross-checked
45Automated test suites
100%Human-approved output
The story
Packaging runs on tribal knowledge. We're compiling it.
Every hard skill in packaging lives in somebody's head. Reading a dieline at a glance. Knowing a stated width is wrong because the drawn one disagrees. Quoting a run without opening a spreadsheet. Stacking a pallet so it survives a humid trailer. A decade of running real production taught us that this craft walks out the door at five o'clock — and that no ERP ever captured it.
PackOS Labs exists to compile that craft into models. Not one giant model that answers everything — four specialists, each owning one craft completely, each grounded in the same corpus of real production dielines and manufacturing records, each checked by an adversarial referee before a human ever sees its output. That's the same discipline a frontier AI lab applies to language, applied to the physical grammar of packaging.
And the lab itself is agentic. The models are developed by fleets of build-and-verify agents: one authors a behavior, others attack it, and what survives is pinned as a permanent regression test. Every correction a human makes becomes curriculum. That loop is why the family compounds — every file quoted makes next month's models sharper than this month's.
The hierarchy
See. Make. Decide.
Three tiers, four models — and no more than that, on purpose. A perception model reads what you send, an adversary argues with it, a generation model builds what production needs, and a decision model commits to the number. Everything each one says traces to a mechanic you can check.
TIER 01 · SEE
Perception
A model that reads artwork the way an engineer does — structure, dimensions, inks — and a second model whose only job is to argue with the first.
PanelmapReferee
TIER 02 · MAKE
Generation
A model that produces production-legal structure: parametric dielines a die maker can cut — every curve press-real, every crease where board wants to fold.
Dieform
TIER 03 · DECIDE
Judgment
A model that puts a number on the line — price from explicit production mechanics plus learned corrections. Never from a guess.
Tally
Panelmapv3See
Reads the file. Sees the package.
Panelmap is the perception model. Drop in a print-ready PDF and it reads the file the way a structural engineer would: which family it is — pouch, label, carton, corrugated — which panels, the true dimensions, gussets and seal zones, ink and material callouts. Even when they're drawn, not written.
It learned where marketing copy can't help: a ground-truth corpus of real production dielines, cross-checked against thousands of manufacturing records. When a file disagrees with itself — a stated width that isn't the drawn width — Panelmap notices, because that disagreement is exactly what it was trained to catch.
Input
Print-ready artwork (PDF / AI)
Output
Structured spec — family · panels · dimensions · seals · inks · material
Grounded in
A ground-truth corpus of 500+ real production dielines; 3,500+ production records cross-checked
Checked by
Referee, on every single import
Ships in
Quick Quote file import · Pack Studio
8 packaging familiesreads drawn AND stated dimsink + material callouts
Refereev2See
The model that checks the models.
Every frontier lab needs an adversary. Referee re-renders what the other models produced and argues with it: do the drawn dimensions match the stated ones? Did a panel go missing? Is a separation pretending to be an ink it isn't?
Disagreements get flagged before a human ever sees the output. Most bad answers die here, in private — which is the point. A model family you can trust isn't one that's never wrong; it's one that catches itself before you pay for the mistake.
Input
Another model's output + the source file
Output
A verdict — pass, or specific flags held for review
Grounded in
A browser-real, end-to-end verification harness
Checked by
45 automated suites on every release; regression pins that make known-good behavior unbreakable
Ships in
Every import and every proof, invisibly
adversarial by designflags, never guesses pastruns on 100% of imports
Dieformv4Make
From numbers to knife lines.
Dieform is the generation model. Give it a spec — or Panelmap's reading of one — and it produces the production dieline: cut, crease, bleed and glue, in under a second, for pouches, labels, cartons and mailers.
Not clip art. Parametric geometry with production rules baked in, so every curve it draws is a curve a die maker can actually cut, and every crease lands where board wants to fold. Change one dimension and the whole structure re-derives — that's what parametric means.
Input
A structured spec (dims, style, material)
Output
Production dieline — cut / crease / bleed — plus 3D-ready geometry
Grounded in
Production die libraries + hundreds of pinned geometry behaviors
Checked by
Referee reconciliation against the source spec
Ships in
Pack Studio · the box & carton library · every quote
< 1 s per structurepouches · labels · cartons · mailersfully parametric
Tallyv2Decide
A real price, from real production math.
Tally prices the run the way an estimator does — material area from the actual blank, plates and tooling, setup, run speed, waste — then corrects itself with what real production has taught it.
What it never does: invent a number. Every figure in a Tally quote traces to a mechanic you can name. And when confidence is low — an odd structure, a new material — it says so and routes to a human instead of guessing inside your invoice.
Input
A structured spec + quantity
Output
A quote — per-unit price with its breakdown
Grounded in
Explicit production cost mechanics + corrections learned from real runs
Checked by
Estimator-parity checks against real quotes
Ships in
quote.packos.ai — live today
mechanics-first pricingzero invented numberslow confidence → human
The architecture
How the family runs your file
One production line. Panelmap reads, Dieform builds, Tally prices — and Referee checks every hand-off in between. Downstream, the same discipline renders photoreal proofs and computes pallet and freight physics, but the intelligence lives in these four.
Why "frontier lab" isn't a costume
What makes this a lab, not a landing page
Trained on truth, not scraped text
The models learn from a ground-truth corpus of real production dielines and thousands of manufacturing records — per-attribute truth tables, not internet vibes. Every file quoted grows the corpus, and the corpus is the curriculum: the flywheel that makes next month's Panelmap sharper than this month's.
Checked like a pressroom, not a demo
Referee adversarially re-checks every import. Forty-five automated suites and a browser-real, end-to-end harness run on every release, and hundreds of regression pins make known-good behavior unbreakable — a change that would regress a real customer file cannot ship.
Honest by architecture
No model in this family is allowed to invent a number. Dimensions come from your file. Prices come from named mechanics. Physics comes from published formulas. And when confidence is low, the system says so and routes to a human — an architecture decision, not a promise.
Built by an agentic lab
The development process is itself agentic: fleets of build agents author each behavior, verification agents attack it, and only what survives the argument ships — pinned as a regression test so it can never silently break. The models aren't just AI products; they're made the way frontier labs make things.
Watch the family run on your file.
Upload real artwork and see Panelmap read it, Referee check it, Dieform rebuild it, and Tally price it — in about a minute.
