INCREDIBLE MACHINES
Robotics model training preview
Powered by our PolyVu data synthesizer.
Overview
The problem. AI learns from data, and the easy data is running out. Language models nearly exhausted the public internet. Robots are worse off. There is no "internet of how systems work" to learn from, so the field films humans doing tasks one at a time. That teaches what a motion looks like, never why it works.
What we built. We reverse-engineered the periodic table of machines: a set of fundamental working parts from which every documented system is assembled. We discovered it computationally, verified it against the whole modern U.S. patent record and can now decompose any system (machine) into that shared alphabet, no matter what words the original document used.
What we sell. Training data built from that alphabet: structured lessons in how systems work: real machines explained, look-alike pairs that differ in exactly one working part, fresh machines that have never been built, and skills ordered by measured complexity from simple to compound. Generated to order, verified, and available nowhere else, because no one else has the alphabet (that we are aware of).
Does it work? We ran an experiment. We trained a popular open-weights model on our data and tested it on a public benchmark we have no connection to. It got measurably better at exactly the skill our data teaches, and the trained model is released openly so anyone can check the scores. Numbers below.
The measured result
Model: gemma-4-31B-it vs. the same model after RL training on our structure-of-machines supervision. Benchmark: NewtonBench (HKUST, arXiv-published — a public benchmark of scientific-discovery tasks; the agent runs live experiments on simulated physical systems and must discover the underlying laws). Full matrix: both agent modes × both task lanes × all difficulty levels, same machine, same scoring, identical protocol for base and trained models.
Agents run in two modes:
- Tool-free — the model works the problem by reasoning alone.
- With code execution — the agent can write and run Python at every step of the experiment loop, using it to plan trials, process measurements, and fit laws.
| Task lane | Agent mode | Base | After training | Change |
|---|---|---|---|---|
| Interactive systems (discover the hidden law of a live physical setup) | Tool-free | 59.4% | 62.2% | +2.8 pts |
| Interactive systems | With code execution | 69.8% | 72.1% | +2.3 pts |
| Symbolic equations | With code execution | 81.9% | 83.8% | +1.9 pts |
| Symbolic equations | Tool-free | 40.6% | 41.0% | no change |
Beyond the headline scores, on the lifted lanes:
- Wrong answers get meaningfully less wrong — numerical error drops 15–50% even in cases where the final answer still misses.
- The trained model is more efficient — it reasons with 2–8% fewer tokens.
- The lift wins the majority of individual difficulty cells, not just the pooled average.
Why these lanes, and not all of them. NewtonBench has a third task family — highly abstract, symbolic counterfactual reasoning — that sits furthest from the physical, hands-on machine behavior our data is built to teach. Under a deliberately small pilot compute budget, we spent measurement effort on the lanes most diagnostic for machine-systems understanding (the interactive-systems lane is essentially embodiment-in-the-loop in miniature), rather than covering every cell for coverage's sake. The third family enters the matrix in the follow-on wave to be published later.
These are pilot-scale, first-lap numbers, deliberately. The wave above ran one training lap under a self-imposed, shoestring resource ceiling. We read them as directional signal: the data transfers capability where it should, the off-lane stays flat, and nothing breaks. With the multi-lap follow-up and access to more compute, we expect materially larger movement.
What this proves and what it doesn't
It proves one thing, and it's the thing this sheet exists for: data built from our systems alphabet carries real training signal, verified on a public benchmark.
A note on who we are. We are not expert model builders, and we don't aim to be. We trained a model for the same reason a miner assays ore: to prove what's in it. The trained model isn't the product, it's the receipt, a proof-of-concept anyone can check. The real opportunity isn't "models trained by us," it's that the data classes we mint — verified, complexity-graded, novelty-certified, generated to order — are an input every serious AI and robotics program needs and could not buy before this work.
What we are not claiming, deliberately:
- Not a universal smartness leap. The lift appears on the lanes our data teaches and is absent on the off-lane. That scoping is a feature: it ties the gain to our data, not to luck.
- The pooled confidence intervals still touch at pilot scale. The next wave widens the claim only if the data earns it.
What's in a data pack
A customer render ships as a small set of manifest-verified files:
- Real machines, explained — systematic decompositions across measured machine families, ordered by measured complexity from single working parts to compound, multi-stage systems, including verified "there is nothing to operate here" negatives, so models learn when to stop looking.
- Identical twins in different words — verified same-machine pairs, plus near-miss pairs that differ in exactly one working part: the distinction between "looks alike" and "works alike."
- Machines that don't exist yet — generated on demand by our synthesizer and verified absent from the entire documented invention record. Training signal that no footage, scrape, or archive can contain.
- Contrastive reasoning sets — coverage across every measured machine family, teaching the boundary between "does the same job" and "does not."
We don't sell a fixed archive. Each render above is a sample drawn from live generators; volume, family mix, and difficulty curve are set by the brief, and the generators run to any scale on request.
Beyond training models
The same machinery that mints training data supplies inputs serious programs buy today:
- Evaluation sets that never go stale — fresh, never-before-seen test conditions generated on demand, so you measure whether a system generalizes instead of remembering. As public benchmarks saturate and leak, new exams become the scarcity.
- Simulation and RL curricula — task ladders ordered by measured complexity, from single working parts to compound multi-stage systems.
- Diagnosis and repair data — chains from symptom back to cause, teaching inspection and maintenance reasoning that video or teleop can't show.
And because the instrument answers "what does this do, and has anyone done it before?" — at the level of function, not keywords — the same capability serves industries far beyond AI training:
- R&D and cross-domain science — surface where two fields independently built the same mechanism under different names, and reuse proven solutions instead of re-deriving them. Every engineered domain has portions of this problem; we've certified real cases (a steroid synthesis route and a yeast-cannabinoid production process that are the same working chain).
- Intellectual property — prior-art and freedom-to-operate triage by function; same-invention reveals that keyword search structurally cannot return; portfolio overlap mapping.
- National security and defense — supply-chain capability census (who can make which functions, where), duplication audit across acquisition programs, and emerging-technology mapping before it has a name.
- Cybersecurity — attack chains are compositions too: recognize incident patterns that are the same underlying mechanism dressed in new tooling, and chart the unexplored chain frontier before adversaries do.
- Electronics and semiconductors — functional equivalence across component vendors and re-clothed circuit redesigns.
- Software and enterprise — architecture reimplementation audits ("division B is rebuilding something division A already shipped"), measurable at last.
- Energy and infrastructure — proven-mechanism transfer between plant domains, plus the diagnosis/repair data above for maintenance-heavy assets.
- Insurance and risk — recall and failure-equivalence mapping: is this failed component the same functional system as a known failure class?
- Due diligence and M&A — what does the target actually own, functionally, and how much of it duplicates what the buyer already has? Priced evidence, not interview impressions.
- Standards bodies and regulators — certified cross-reference between standards written in different vocabularies, and honest maps of what a standard does and doesn't cover.
- Education and assessment — curricula ordered by measured complexity, and exams generated fresh so they can't be memorized. Individually tailored lessons, instantly.
Why this exists nowhere else
The inputs are public. The alphabet is not. A competitor can download the same documents, but turning words into verified, complexity-ladder, is/isn't-the-same training supervision requires the discovery machinery we built, the certified corpus it produced, and the falsification records of every approach we measured to death along the way. Our core competency is that instrument and the data it certifies; training runs are how we prove it, not the business.
Samples shared under NDA. Full evidence annex (source-level receipts, claim filing trail) available to diligence teams internal-only.
- Downloads last month
- 12