What you get —
and what you don’t

MatrixAI Studio runs on your own machine. You frame the problem and it makes several engines compete on your data, picks the winner by the mean of a cross-validation, keeps the test set for the final figure and tells you why — every decision with its reason, and the choice written in a receipt. If you would rather build one network yourself, expert mode is still there. There is a demo in the browser with sample data, the core is AGPL, and the manuals show every screen. This page says what that is good for — and, just as plainly, what it is not.

Several engines competeTest set kept apartEvery choice with its reasonRuns on your machine
Read this first

Every screenshot on this page was taken driving the real product — the study ones from the same live session as the Studio tour, the expert-mode ones from the manual’s. Every number was measured; where a result was bad, it is shown as bad. Nothing here is a mock-up. The first four sections are the main path, the study; the rest is expert mode, and it is labelled as such.

The study

Several engines compete — and the champion says why

You frame the problem — the target, the kind of problem, what one row stands for — and the study tries every engine on several parts of your development data, each with its own cross-validation. The standard package races gradient-boosted trees (LightGBM and scikit-learn) against a reference baseline and, since v2.8, our own neural network (in both packages, with its own time: 60 s per attempt, added to the budget, so no other engine loses a second). It only competes if it was measured on every part of the cross-validation, and the study picks per dataset: it wins only where it is the best. The GPU package keeps our previous network too, as an experimental engine; in the CPU package the new network takes its place. The champion is the one with the best mean over its parts, and the screen names it, says what that engine is and gives the reason in plain words. When the paired comparison against the runner-up does not show an improvement, it says that too: a choice under uncertainty, not a clear winner. A few engines, not hundreds, and no hyperparameter search.

Results: the champion by its engine name, what that engine is, the reason for the choice and the Save this study button
The recommendation, from a live session: the champion, what it is and why it was chosen. Open full size ↗
The study

The test set stays apart, and the evidence is written down

The figure that counts comes from data no candidate saw while competing: the test set is kept intact until the end, and the comparison shows each engine’s mean over its parts — the one that decides — with the range, so a lucky split cannot pick the champion. Below it, the evidence says what applies and what does not, and why, and the receipt records what competed, what won and under which rule. The receipt comes out Unsigned until you configure your own signing key; its signature is an HMAC, so a third party cannot verify it without that key. It documents the choice — it is not a certificate.

The Evidence section and the receipt, marked Unsigned because no signing key is configured
The evidence and the receipt, marked Unsigned because no signing key is configured in that session. Open full size ↗
Yours to take

The winner’s package, and the whole study

Build the package and you get the winner with its preparation recipe and a predict.py that predicts like the screen does — with Python, outside the Studio, but it needs the Studio’s engines: it does not run on a machine without them. The receipt is not in that package: it travels in estudio-completo.zip, the full study, which you reopen in another Studio. A page that predicts in the browser (ONNX) is offered only when LightGBM wins a binary classification, with its decision chosen and no date columns; otherwise the option is shown switched off with its reason. Your data never leaves your machine — except the 5 rows and the counts you send to your LLM if you tick the optional proposal described below.

Save and take the model with you: the package built, its download link and the list of what has been checked about it
The package built: its download link and what has been checked about it — and what has not. Open full size ↗
The study · optional, since v2.10

The LLM can propose the framing — and you confirm it

If you have an LLM configured in Settings, you can tick “Let the LLM propose the fields”. It then proposes the empty fields of the framing — target column, problem type, positive class, observation unit, prediction time and horizon — and each proposed field carries a “Proposed by the LLM” mark until you edit it. What goes out: the column names, a few counts for each column (type, % empty, distinct values) and 5 real rows of your CSV, to the LLM configured at that moment, which the notice names before you tick. What you send is your responsibility: with personal data, do not tick the box or remove it from the CSV first. What it does not do: it does not fill in what you already wrote, it confirms nothing — you review and confirm — it needs a configured LLM, and it is not in the hosted demo. Without the tick, this sends nothing.

The framing form with “Let the LLM propose the fields” ticked: the notice naming the configured LLM and the fields marked Proposed by the LLM
The LLM proposal, from a live session of v2.10: the notice says what is sent and to whom, and each proposed field is marked. Open full size ↗
Expert mode

Or build one network yourself

Expert mode is still in the product, behind a switch: Turn on expert mode on the Studio’s home screen. There you describe one model in a sentence, upload a CSV or start from a template, and the core builds that one network, phase by phase — the way of working the Studio had before the study. It is a different tool: nothing in it makes engines compete. What follows is what expert mode gives you.

Expert mode · one sentence in

Describe it — the schema stays on the table

Three ways in: a sentence, your CSV, or a template from the catalogue. Whichever door you take, the core reads the data, proposes a target with its reason — and the alternative it considered — and prints the schema it inferred: every field, its type, its range, all editable. It proposes; you decide. And the screen warns you about the part that matters: a wrong range makes the model learn over a domain that does not exist.

The Data phase: file preview, proposed target with its reason and alternative, and the inferred schema with editable types and ranges
The Data phase, from a driven session: the file, the proposed target with its reason and its alternative, and the inferred schema — field by field, editable. Open full size ↗
Expert mode · auditable

A trace with names on it

The audit is not a training summary. Six checks run against the model itself — parser, verifier_agent, safety_agent, typecheck, python_compiler, backend_contract — and they re-run on every change, so the verdict cannot go stale behind your back. The pipeline stages that carry no pass/fail are listed apart with whatever they did report, instead of disappearing under a green tick. The whole verification downloads as a file, and the trace links the model to the data it was prepared with and the training run it belongs to.

The Audit phase: six named checks with their result, two pipeline stages with no control attached, and the model trace
The Audit phase: six named checks, two stages with no control attached — printed, not hidden — and the model trace on the right. Open full size ↗
Expert mode · before training

Checked before a single weight moves

Before training, the model is already an object you can verify: the type check types the network and states its interpretability level, and the parameter count is printed so you can redo the arithmetic yourself — a 64 → 32 → 1 network over three inputs is 2,369 parameters, and that is what the screen says. The resource estimate arrives with figures, not adjectives, and it works in both directions: a small model announces kilobytes, and when we asked for a 2,953,150,466-parameter network, the answer was that training it needs ~26.8 GiB — the hosted demo refuses it outright, and the downloadable Studio shows the warning with its figures and leaves the decision to you. A tool that tells you the bill before you commit is the difference between an estimate and a promise.

A model before training: build pipeline with nine stages, proposed architecture with parameter count, estimated resources in KiB and the data ceiling
A 609-parameter regressor before training: the sizing rationale, the estimated resources (2.1 KiB of weights, marked orientative), the data ceiling, and the checks already run. Open full size ↗
Expert mode · yours to take

Its export predicts without MatrixAI

This is the expert-mode export, not the study’s package. The self-contained bundle carries the model in ONNX, a predict.py that loads it and validates the schema, the manifest with its hashes, and the model card with its metrics and its limits. You feed it raw values — no MatrixAI installed, no service to call. And the parity is measured, not assumed: in an August audit of that export, the exported model, loaded with a plain ONNX runtime, returned the same answer as the Studio on all six test inputs — six of six.

The Deployment phase: ONNX, WASM bundle and self-contained Edge bundle, each described by what it contains
The Deployment phase: three formats, each described by what it really contains — and the self-contained bundle as the one that opens and predicts on its own. Open full size ↗
Expert mode · a real case

Real data, declared limits: tomorrow’s rain in Santander

The template catalogue includes a case built on five years of real daily history for Santander, Spain (Open-Meteo): temperatures, pressure, humidity, wind, cloud cover, dew point and today’s rain, with the target built by shifting rainfall one day back — each row predicts tomorrow using only what was known that day, never data from the future. The card also carries, in red and before you create anything, the limit of its data: it does not allow commercial use. Next to it, a wave-height case on five years of real hourly marine data. That is the pattern everywhere: what something is good for and what it is not, printed where you decide.

The template catalogue with the rain case for Santander: real data from Open-Meteo, how the target is built, and a red licence warning on the card
The catalogue: the rain case declares its source, how the target is built, and its licence limit — on the card, not buried in terms you meet later. Open full size ↗

The full expert-mode cycle, screen by screen, is in its manual — captured from a driven session and honest about its numbers: its walkthrough trains on generated rows and reports a chance-level result as exactly that, because showing that the product declares a bad run is worth more than a prettier screenshot. The main path, the study, is in the tour.

The limits

What it does not do

This product states its limits on every screen, and this page follows the same rule. Read these before you download — the rest is easier to trust afterwards.

It is not a chat, and it does not search hundreds of models
There is no conversation. The study makes a handful of engines compete — gradient-boosted trees, a reference baseline and, since v2.8, the neural network (in the GPU package, also the previous one as an experimental engine) — not hundreds of candidates, and it does not run a hyperparameter search. In expert mode you declare one model and the core builds that one; nothing competes. If you want to throw a million heterogeneous columns at a black box and tune it for the best score, this is the wrong tool.
No images, no audio
Today the study works on tables, with at most one free-text column per study (an experimental text-only candidate competes with the table models). Expert mode adds time series through the template flow and free text through transformer models. Nothing else. Multimodality is on the roadmap, not in the product.
Without a GPU, the neural network and the transformers train on CPU — more slowly
The neural network that competes in a study, and the transformer models of expert mode, train on torch, which both packages install on their first start, on your computer: the GPU package downloads PyTorch with CUDA, and the CPU package PyTorch for CPU (about 200 MB). In the CPU package they train on CPU, more slowly than with a GPU. If the study’s estimated memory (about 1 GB plus half a GB per million cells, with a 15 % margin) exceeds the container’s, the network does not compete in that study and Results says so, with both figures. What it does in the Studio was measured on 13 public datasets, without a GPU and with 6 GB of memory for the container. CPU package: The champion improves on 2 of 13 datasets (difference in points of its test score: dresses-sales +4.4, pc1 +1.6), drops on none and none stops completing. On 2 the study did not end with a champion, with the network or without it. On 2 the estimated memory exceeded the container’s and the network did not compete (Allstate_Claims_Severity: 15.3 GB estimated against 6 GB; KDDCup09_appetency: 7.8 GB estimated against 6 GB). What it does on a GPU has not been measured. The 38/40 on “How we measure” is from Phase 0, not what you get in every study: the study picks per dataset.
Big tables and big networks need real hardware
A study compares several engines and each one needs memory: measured with the CPU package, about 1 GB plus half a GB per million cells (rows × columns), and a 50,000 × 231 table did not finish with 6 GB for Docker; with 9 GB, it did. In expert mode the product does the arithmetic out loud: asked for a ~3-billion-parameter network, it answered that training needs ~26.8 GiB, and the hosted demo refuses it.
Your model is as good as your data
The Studio validates shapes, types and ranges — it cannot validate the truth of your data. Wrong labels teach wrong answers, and the study does not fill in what it cannot know: the unit of observation is yours to declare. In expert mode a wrong declared range makes the model learn over a domain that does not exist, which is why its schema is editable.
There is no community yet
No forum, no already-answered questions to search. If you install today you are among the first users, with both sides of that: nobody has walked your path before you — and your bug report or question lands directly with the person who builds the product, not in a queue.

Try it without installing

The demo runs in the browser against the real core, with sample data — no account, nothing to install. It is limited: training has a cap on epochs and seconds, it does not export models, and a file you upload there goes to our server, which the download never does. The tour and the manuals show every screen of the real Studio from driven sessions. The core is AGPL, on GitHub. When you want it on your machine, the download is one ZIP and one script.

Online demo with sample data ↗Get MatrixAI Studio