Capabilities

A single pass over your tables returns one bundle. The bundle holds the industry of each table, the role of each column, how tables relate, filled gaps, and predictions, each with its own confidence.

A slice that does not apply is present and empty, never missing.

This page explains each output: what it means, how it is produced, how to read it, and where it stops being reliable. It is the practical companion to Architecture, which explains how the model is built, and to Benchmarks, which explains how each capability was developed and tested.

One pass, one bundle

The model reads raw tables and answers several questions at once. It does not run a separate tool for each.

raw tables  ->  one pass of the model  ->  one bundle of outputs

The bundle has the same shape for every table. That is deliberate.

Downstream code can be written once, and an empty slice is a normal state, not an error.

An analogy helps. Hand a stack of unlabeled files to an experienced analyst and ask for a first read.

A good analyst tells you what the files are, what each field holds, how the files connect, what is missing, and what can be predicted. The bundle is that first read, with a confidence on each statement.

Why they all come together

The outputs share one internal representation. Axial attention reads rows and columns, and a Perceiver-style block gives a table-level view.

Small heads then read that same representation. So the work is shared and the answers are consistent with one another.

If the sector comes out as retail, the column roles are read in that light. See Architecture.

What the model reads

The model reads values, not names. Column embeddings are always zeroed, so the model never uses a column's identity.

That is why the outputs hold when headers are stripped, coded, or misleading. See column name independence.

1. Sector

The sector is the industry a table belongs to, such as retail or hospital operations, inferred from cell values alone. The ask is hard on purpose: no metadata, no labels, no column names.

What you get

• A top guess.

• A short list of the most likely sectors.

• A confidence on each entry.

It works when headers are stripped or opaque. Use it to catalog a data lake, route incoming files, or triage a dataset before anyone opens it.

How it works

The sector is a property of the whole table, so it comes from the global view. The Perceiver-style latents summarize the table, and a hierarchical head first picks a coarse family and then a specific sector inside it.

A key finding shaped the head. A marginal fingerprint of each column could not separate neighbouring sectors such as developer tools and data analytics.

Joint pair correlation between columns could. So the head leans on how columns relate, not only on what each looks like alone.

What it was tested on

The test is blind sector identification: 504 real datasets, column names zeroed, no labels, no metadata, scored top-1 and top-5 against a uniform random baseline. The ground-truth labels come from independent judges, never from the model itself.

The headline is the full 504 datasets. A clean subset is kept only as a sanity check, because a perfect score on an easy subset proves little.

See Blind sector identification.

How to read it

• A high confidence on a distinctive sector is dependable.

• Two close sectors in the short list, such as banking and insurance, are a sign of sibling confusion. These are the main remaining errors.

• Some datasets are ambiguous even to human labellers. Twenty-four datasets are reported separately for that reason.

2. Column profile

The column profile describes every column: its role, its type, and how much of it is missing.

The fields

{
  "name": "c3",
  "role": "phone",
  "type": "string",
  "missing_pct": 0.02
}

The column c3 has no helpful name. The model still reports a phone role from the values.

Role versus type

Type is the storage shape: a number, a date, a string. Role is the meaning: an email, a currency amount, an identifier.

They are different questions. A column of nine-digit numbers can be a numeric type with an identifier role.

Treating it as a measure would be a mistake, because averaging identifiers is meaningless.

Why it matters in practice

• Routing. Send date columns to time handling and currency columns to money handling.

• Governance. Use the personal-data flag to mask or gate columns before they travel.

• Safety. Identifying columns are never filled by imputation.

How it works

The model reads the values of a column and how they relate to the other columns. The column attention layers see the whole column, so they learn what a typical phone number looks like and flag values that do not fit.

Row attention adds context from neighbouring cells, such as a postal code beside a city. See cell encoding.

3. Cross-table map

For two or more tables, the cross-table map says which columns and which rows describe the same thing, even with no shared key and different formats. This is the part of the bundle that deals with systems that do not share an identifier.

What you get

The map has several parts.

• Column alignments. Pairs of columns that carry the same attribute, each with a confidence and a verbatim example from each side. For instance, 555-0142 and +1 555 0142 under one phone attribute.

• Entity matches. Pairs of rows that describe the same real-world entity, with a confidence and the attributes the pair was matched on.

• A unified schema. A proposed fold of the tables, split into shared columns and columns that appear in only one source.

• Unified rows. The result materialized as joined records, one per matched entity, with provenance for each field and the raw variants of shared values.

When shared variants disagree beyond formatting, that is flagged as a possible mis-alignment rather than silently resolved by picking one side.

A proposal, not a command

Every alignment and every match ships its confidence and its evidence. The map is a proposal for review.

High-confidence matches can be acted on automatically, and the rest can be queued at a threshold you choose. Nothing is applied for you.

An analogy: two address books, one from a phone and one from a bank. A careful clerk matches entries by eye, checks the phone number and the surname, and keeps a note of why each pair was matched.

The map keeps that note.

How it works

The model matching, which column corresponds to which, uses three channels:

1. adapter embeddings of columns and cells,

2. a channel of 28 column statistics,

3. a name channel.

Pairs are scored and normalized, and only mutual best one-to-one matches are kept. Entity matching, which rows are the same entity, works with no keys.

The recipe that worked was a short training run, a two-model ensemble, and a calibrated threshold. See Entity and schema matching.

What it was tested on

Entity matching was tested on six multi-table datasets with no keys and no shared identifiers. The model matching was tested on the Valentine scenarios, scored as F1 with the averaging rule fixed before scoring.

Every published competitor sees column names. The model does not use them in its encoder.

The margin is widest where text matching gives out: records that describe the same entity in different words.

One caveat applies to a rival, not to the model: one published competitor was trained on the benchmark data. That is a leakage caveat for them.

How to read it

• Use the confidence threshold to separate automatic action from review.

• Read the verbatim examples. They tell you in one glance whether an alignment makes sense.

• Treat disagreeing shared variants as a flag, not as noise.

4. Missing-value imputation

Numeric and categorical gaps are both filled. Confidence is reported per row, and a categorical fill is a class label, not just the most common value.

What you get

• A list of filled cells with the table, row, column, value, and method.

• A confidence for each affected row.

• Original cells are never overwritten.

• Identifying columns are never filled.

The confidence is at row level, not cell level. A row with several filled cells gets one confidence for the row.

Why it fits the model

Imputation is the pre-training task. The model learned by hiding cells and recovering them, so a missing cell at use time is the same problem it practiced on.

See Pre-training and masked cell modeling.

The chain behind the numbers

On the imputation benchmark, the final system is a chain of three arms: a ridge arm, an in-context arm, and a neighbours arm. The arm for each column is chosen on masked holdouts, with fixed proportional margins against the plain ridge arm.

A plain ridge chain matched a classical multiple-imputation method exactly, which gave a verified floor to measure against.

For categories, the expected value replaces the single most likely class when the metric is squared error, because the mean is optimal for squared error.

The three kinds of missingness

The model was measured under all three on 20 real datasets, with the widest margin under not-at-random missingness. Categorical imputation was measured with macro-F1 on masked categorical cells and has no published competitor.

See Missing-value imputation.

What stayed open

On two synthetic settings the best published multiple-imputation figure stayed ahead of my own runs, and I left those rows as reported. On datasets with few columns or few rows the chain has little context and the gain is small.

How to read it

• Low-confidence rows deserve a human look.

• A filled value is an estimate. It is a better guess than a mean fill, and it is still a guess.

• Do not let imputed values flow into a final decision without a gate on confidence.

5. Predictions

The model does classification, regression, and anomaly detection, all in context on the labelled rows already in the table. Nothing is trained.

See in-context prediction.

What in context means

The labelled rows act as a support set. To predict a new row, the model compares it with the supports and reads off an answer.

There is no fitting step and no new model per table. An analogy: instead of hiring and training a clerk for each new filing cabinet, you hand an experienced clerk a few solved examples and ask for the next one.

Classification

Classification returns, per row, a label, a confidence (the top class probability), and the full probability vector. The classes come from the target column.

Rows whose target is missing are counted as dropped and never become a predictable label.

On the row-level prediction boards the model runs one default configuration. It is first on the classification and binary boards at every board size I tested.

The overall board only became valid after I found a harness error, and I re-checked that no row was imputed. See Row-level prediction.

Regression

Regression returns a value, a median, a spread, and quantiles. So you can read a range rather than a single number.

{
  "row": 0,
  "value": 12480.0,
  "median": 12010.0,
  "std": 3120.0,
  "quantiles": { "0.1": 8400.0, "0.5": 12010.0, "0.9": 17900.0 }
}

Underneath is a 999-quantile head trained with a CRPS loss, followed by split-conformal calibration with an isotonic correction. Conformal calibration is a way to make intervals cover as often as they claim.

In the benchmark, the model has the lowest median CRPS and the best mean rank on the merged board of 102 regression datasets, with one sealed configuration and no per-dataset tuning. Interval coverage was the weak metric before calibration.

See Probabilistic regression.

Anomaly detection

Anomaly detection runs unsupervised, with no target. It returns an anomaly score, a flag, and the threshold that was used.

The detector has three model-based channels: the residual of the imputation head, nearest neighbours in the model's embedding space, and nearest neighbours in the raw space. An isolation forest joins as an auxiliary channel.

A pseudo-anomaly selector decides which channel to trust without labels. Fake anomalies are built from the training rows by shuffling features and injecting uniform values, each channel is measured on them, and the channels are weighted with a softmax.

The ranks are then fused. See anomaly detection and the benchmark page on Anomaly detection.

The benchmark is semi-supervised: trained on normal rows only, scored on a test set. The detector is first among thirteen methods by both average rank and AUROC.

Typical uses are fraud screening, equipment monitoring, and data-quality checks with no labelled history.

Choosing the target and the task

Target and task can be chosen for you or by you.

The response states what was chosen and why, and lists the candidate columns with the reason each was selected or ruled out. You see the decision and the rationale.

Prediction when columns are unnamed or gappy

Two tests are about robustness. In the metadata test, 20 numerical classification datasets run under three naming conditions: full names, random strings, and names removed.

Models that read headers lose roughly seven AUC points when headers vanish. The model is the only one in the comparison whose accuracy does not fall.

On pure numeric classics without semantics a stronger prior-based rival still leads, usually by a few thousandths. See Metadata independence.

In the missing-data test, ten datasets get masks of three types and several rates, and AUC is measured after injecting missing values into the features. The mean AUC is above the published method, by a narrow lead that I report as one.

See Missing-data robustness.

6. Synthetic data

The model can generate a synthetic table for a sector with realistic column ranges. Use it for testing, sharing, or filling thin data.

See synthetic data generation.

Good uses

• Testing. Fill a staging system with plausible rows that contain no real person.

• Sharing. Show the shape of a dataset without releasing the dataset.

• Thin data. Add rows where there are too few to learn from.

A caution

Synthetic data is a stand-in. It is useful for testing and filling gaps, and it is not a substitute for real records in a final decision.

Anything learned from synthetic rows should be checked against real ones.

7. Held-out block

The held-out block is a score measured on rows the model did not see, for persistent configurations. It answers the question: how good is this on my table?

How it is computed

A stratified test partition is held out, with a default of 80/20. The model predicts those rows from the remaining rows in context, and the predictions are scored against the true values.

The report records the method, the exact partition sizes, and the seed. Every score is stated against a baseline, so a score is always read next to what a trivial guess would achieve.

What the score claims

It claims one thing: performance on held-out rows drawn from the same table. It does not claim performance on a different distribution, after the world changes, or on classes absent from the table.

See Evaluation.

Confidence, everywhere

Every output carries a confidence, and the kind of confidence depends on the output.

Confidence is not certainty. A probability of 0.9 means that the model expects to be right nine times out of ten among predictions like it, if it is calibrated.

It does not mean any single answer is guaranteed.

Continual learning as a capability

Beyond one pass, the model can take on new tasks without a full retrain. Tree ensembles retrain fully for each task, and frozen foundation models have no update path at all.

See continual learning for tables.

The recipe that stayed uses adapters that do not depend on the number of columns, experience replay with 48 raw rows per task, and regularization such as elastic weight consolidation. The model is the only one in the comparison that can take on new tasks without a full retrain.

Retention comes from replay, not from the weights alone, and the buffer grows linearly. See Continual learning.

One checkpoint holds it all

All of these capabilities live in one object. The core, every head, and every adapter are merged into one unified checkpoint of about 2.18 billion parameters with the code embedded.

It can be stored at half, 8-bit, and 4-bit precision. See One checkpoint and compression and serving.

Putting capabilities together

The outputs are most useful in combination. Four common patterns follow.

Understand a table nobody documented

1. Read the sector and its confidence.

2. Read the column profile for roles, types, missing share, and personal-data flags.

3. Decide what the data can support.

Merge two systems with no shared key

1. Read the column alignments and check the verbatim examples.

2. Read the entity matches above your confidence threshold.

3. Review the unified schema and the disagreeing variants before accepting.

Score rows with proof

1. Choose a target or let the model propose one.

2. Read the per-row predictions and their confidence.

3. Read the held-out block against its baseline before trusting the score.

Clean a table with holes

1. Read the missing share in the column profile.

2. Read the filled values and the per-row confidence.

3. Gate on confidence and review the rest.

What the capabilities do not do

• They read the table you give them. Quality depends on how representative that table is.

• Predictions reflect the labelled rows provided. Very small or heavily biased samples limit what can be learned from them.

• A held-out score is local to the table.

• Regression and multiclass boards are behind the leaders.

• Unusual or mixed formats can lower confidence even though names are not required.

See Limitations for the full list.

Where each capability comes from

Standing rules for every claim

Competitor figures are third-party published values, never re-run by me, with the snapshot date pinned for live boards. My figures come from one sealed configuration per benchmark, with no per-dataset tuning.

Results measured under different datasets, metrics, or masking schemes are never blended into one number. Each run is checked for contamination against the training corpus.

Frequently asked questions

What does the model return for a table?

One bundle with the sector, a column profile, a cross-table map for two or more tables, imputed values, predictions, and, for persistent configurations, a held-out block. Each output has its own confidence, and a slice that does not apply is present and empty.

Do I need column names for any of it?

No. The model reads values, so a column called c3 holding phone numbers is understood as phone numbers, and the sector holds with headers stripped.

Names can help a human reader, and unusual or mixed formats can still lower confidence.

How does it predict without training on my table?

It predicts in context. The labelled rows in the table serve as a support set, and the model compares each new row with them.

No weights are updated, and the held-out block measures the result on rows it did not read.

Can it tell me how uncertain a number is?

Yes. Regression can return quantiles, so you read a range such as the tenth to ninetieth percentile instead of a single value.

Calibration makes those intervals cover as often as they claim.

Can it find the same customer in two systems with no shared ID?

Yes. The cross-table map aligns columns and matches rows from the values alone, each with a confidence and evidence.

It is a proposal for review. High-confidence matches can be acted on and the rest queued for a person.

How are missing values filled, and can I trust them?

Numeric and categorical gaps are filled using the structure of your own table, with a confidence per row. They are better than a mean fill, and they are estimates.

Low-confidence rows deserve review, and identifying columns are never filled.

What kind of anomalies can it find?

Rows that do not fit the normal pattern of the table, scored without a target. It combines the imputation residual, two kinds of nearest-neighbour distance, and an isolation forest, and it chooses between them with pseudo-anomalies, so no labels are needed.

Can the model name the industry of a dataset?

Yes. It returns a top guess and a short list with a confidence on each, from raw cell values alone.

The remaining errors are mostly sibling sectors, such as banking and insurance, and some datasets are ambiguous even to people.

Can it learn new tasks later?

Yes, through adapters, a small replay buffer, and regularization, without retraining from scratch. Retention depends on replay, and the buffer grows with the number of tasks.

Is the held-out score a promise about production accuracy?

No. It describes unseen rows of the same table at a point in time.

A different distribution, a changed world, or classes absent from the table are outside its claim.

Summary

The model returns one bundle per pass: the sector of each table, a profile of every column, a map between tables, filled gaps, and in-context predictions with classification, quantile regression, and anomaly scores. It can also generate synthetic tables and, for persistent configurations, report a held-out score against a baseline.

All of it comes from one merged checkpoint that reads values rather than names, so the outputs hold when headers are missing or misleading. Each output carries a confidence, each benchmark claim comes from one sealed configuration, and the limits are stated next to the results.

For how it works inside, read Architecture, for how it learned, read Pre-training, and for the full development record, read Benchmarks.