Our mission

Useful AI that does not need a data centre.

We build small language models from scratch — our own data, our own code, our own weights — small enough to run on a modest server, a mini PC, or in time a phone. Private by construction rather than by promise.

366M
Parameters
< 1 GB
RAM at 4-bit
0
Outbound calls
One-time
Licence, not a subscription
wide hero image
The short version

We build AI that runs on your hardware, so your data never leaves it.

Most AI today works the same way: your document, your customer’s passport, your employee’s CV is uploaded to somebody else’s servers in another country, processed there, and you are asked to trust what happens next. For a great many businesses, that is the single reason they have not adopted AI at all.

REX42 is our answer. There is no API call to anywhere. The model sits inside your building and the data stays there with it. We are not trying to beat the largest models at being large — we are trying to beat them at being useful in the places they cannot go.

Private by design
The model runs on your own machine. No upload, no API, no third-party retention policy to trust. Unplug the network and it still works.
Small by choice
Built to run on a modest server, a mini PC, or a laptop — not a GPU cluster. Lower hardware means lower cost, and that saving is yours.
Built for your job
Trained for the task you actually have, on the hardware you actually own. You receive the weights under a one-time licence.
Why small is the difficult problem

Making a model smaller while keeping it useful is the harder engineering task.

There is a comfortable path in AI right now: more data, more GPUs, bigger model. It works, and it requires capital only a handful of organisations on earth possess. Almost none of the small-model problem can be solved by spending money.

Every parameter earns its place
A large model can afford to know things badly. A small one cannot — capacity spent on trivia is capacity taken from the job.
The training data has to be exactly right
A large model tolerates mediocre data because it has seen so much else. A small model learns your mistakes faithfully. We have watched it happen and rebuilt our datasets because of it.
The system carries more of the load
The model cannot be relied on for judgement, so validation lives in code, facts come from retrieval, and anything that must never be improvised is never generated.
Reliability is engineered, not hoped for
A model that is right 80% of the time and honest about the other 20% is worth more in business than one right 90% of the time and confident always.
n image
Small by choice

The discipline of smallness forces you to understand the problem.

Every parameter has to earn its place, every training example has to be right, and the system around the model has to carry the judgement the model cannot. None of that can be solved by spending money — which is exactly why it is worth doing.

A large model can afford to know things badly. A small one cannot — capacity spent on trivia is capacity taken from the job you are paying it to do.
Bad data shows up immediately. Our first model scored well on documents we had generated and poorly on real ones, so we rebuilt the training set from real files.
Refusal is engineered, not hoped for. The system discards any value it cannot find in the source rather than producing a confident guess.
366M
Parameters
0.18 GB
Weights at 4-bit
< 1 GB
RAM to run
What that means for your model
The economics are the point

A one-time cost that does not scale with your headcount.

A large model in a data centre costs a subscription per user per month, forever, and the price is set by someone else. A small model on your own hardware costs the hardware — once — plus the electricity.

The usual way
Per user, per month, forever
Cost scales with headcount and volume. Pricing, rate limits and model versions change without your consent. Your data is the input to someone else’s roadmap.
The REX42 way
Hardware once, electricity after
For a business processing a few hundred documents a day, that is the difference between an operating expense that grows with the company and a capital cost that does not.

Lower hardware requirement means lower monthly cost, and lower monthly cost is what puts AI within reach of the businesses currently priced out of it. That benefit lands with the customer, not with us, and that is deliberate.

Our position on the scale race

We are not in the race, and we would not win it.

A system is only useful if it can be deployed where the work is. A model that needs a rack of accelerators cannot run in a clinic, a warehouse office, a shipping agent’s back room, or a government department that is not permitted to send data outside the building — exactly the places where routine document work eats hours of human time every day.

The scale race What we work on
Bigger models Models that fit the hardware you already own
More GPUs Efficiency — getting more out of far less
General capability Doing a specific job dependably
Cloud APIs Running inside your own network
Impressive benchmarks Being honest when it does not know
We do not claim our 366-million-parameter model competes with a frontier system on general intelligence. It plainly does not, and any vendor telling you otherwise should be treated with suspicion. We claim something narrower and more useful: for a defined task, on your own hardware, with your data never leaving the building, a small well-trained model is the better tool — and often the only permissible one.
What we have learned in the open

A research page should say what has been hard, not only what has succeeded.

Training data quality decides everything
We built a model that scored well on documents we had generated and poorly on real ones. The cause was not the model — our synthetic documents were too tidy. Real business cards have logos that confuse text recognition; real invoices put the total in a box far from its label; real CVs put the objective paragraph where the job title should be. We rebuilt the training data from real documents, with every personal detail substituted so that layouts are learned and people are not.
Honesty is a feature you have to engineer
Our first models invented values when they could not read a document. A confident, wrong passport number is more dangerous than a blank field. The system now refuses when an image is too unclear and discards any value it cannot find in the source text. It says “I could not read this” rather than guessing, by design.
Small models need a system, not just a prompt
Anything that must never be improvised — prices, discounts, contact details, company facts — is answered from approved text in code, not generated. Anything the model produces is checked against the source before it is shown.
Measure on reality, not your own test set
Every claim we publish comes from testing against real documents, and we record the failures as carefully as the successes. It is the only way to know what is actually true.
In the open

What the work actually looks like

n image
Data
Real documents, substituted
Training sets are built from real client documents — with every name, number and photograph substituted first. The model learns how an invoice or an Emirates ID is laid out, and never learns a single real person.
n image
Evaluation
Measured on reality
Accuracy is measured against held-out real documents, not the synthetic set we generated. Failures are written down as carefully as successes, because a score on tidy data tells you nothing about a photograph taken at an angle.
n image
Research
Distributed training
Research, not a product yet: many ordinary devices training one model together, each learning from what it already holds and sharing only the learning. The same privacy principle as local inference, applied to training.
Next: distributed training

Why should intelligence require one enormous machine, when the world is full of idle small ones?

Every person in the room has a phone. Most have a laptop. Many have a desktop with a graphics card. Each has real computing power, and for most of the day it does nothing at all. Meanwhile the accepted way to train a model is to put a very large number of GPUs in one building and spend weeks of money and electricity.

We are working on a way for many ordinary devices to contribute to training one model together. Each device trains on what it has locally and shares only what it learned — never the underlying data. The contributions are combined into a model better than any one device could produce alone.

No central data centre
The training capacity is the network itself.
Data never moves
Each device learns from its own information and shares only the learning — the same privacy principle as our local models, applied to training.
The cost collapses
Instead of one organisation paying for a GPU cluster, many participants contribute a little spare capacity.
Participation is open
Building capable AI stops being the exclusive privilege of those who can afford the hardware.
Stated plainly
This is research, not a product
Serious problems remain: keeping contributions synchronised across unreliable connections, verifying that a contribution is genuine, handling devices of wildly different speeds, and proving the combined result is really as good as centralised training. These are difficult and we do not claim to have solved them. What is already built is the foundation — the training code, the data pipeline, the evaluation and the deployment for a small model made from scratch.

Tell us the task and the hardware.

We will tell you honestly whether a small private model can do it — and if it cannot, we will say so.