# schemalabs.ai: a large tabular foundation model

Schema-2 is the large tabular foundation model I built end to end: architecture, pre-training data and objectives, evaluation, serving, and the platform around it. It has a core of more than 1.5 billion parameters and about 2.18 billion once every head and adapter is merged into one checkpoint. It reads raw tables directly, with no serialization, no preprocessing, and no column names.

**In short.** One checkpoint, more than 1.5 billion parameters in the core, about 2.18 billion merged. Axial attention over rows and columns, a Perceiver-style table-level path, zeroed column identity, small task heads, adapters for continual learning, and quantized copies at 16, 8, and 4 bits. It is a Data Language Model, the class defined in [arXiv:2605.06290](https://arxiv.org/abs/2605.06290). For the concepts first, read [What is a large tabular foundation model?](https://www.ozercemkelahmet.com/articles/large-tabular-foundation-model)

## Where to find it

The project is a product with its own site, documentation, platform, API, and MCP server. Each link below opens the live thing.

LinkWhat it is

[www.schemalabs.ai](https://www.schemalabs.ai)The product site: the model, the model registry, research, solutions, and the platform entry.
[docs.schemalabs.ai](https://docs.schemalabs.ai)The documentation and API reference: quickstart, authentication, models, data, outputs, endpoints, held-out reports, integrations, and troubleshooting.
[platform.schemalabs.ai](https://platform.schemalabs.ai)The web platform: dashboard, data, quick runs, workspace, endpoints, reports, chat, and API keys.
[MCP server](https://docs.schemalabs.ai/mcp)One remote server at `https://mcp.schemalabs.ai/mcp` for Claude, ChatGPT, Cursor, VS Code, Gemini CLI, and any MCP client.
[Model registry](https://www.schemalabs.ai/model-card)The model card of record: intended use, training data, evaluation, lifecycle, and known limitations.
[arXiv:2605.06290](https://arxiv.org/abs/2605.06290)The paper that defines the Data Language Model class.

## The product around the model

A model is only useful when something can call it. The same model sits behind four surfaces that share one output bundle and one usage meter.

SurfaceWhat it does

PlatformDashboard, data catalog, quick runs, a workspace to compose and publish endpoints, reports with side-by-side comparison, chat over an endpoint's pinned data, and API keys with scopes. Every button is a call to the same API.
REST APIRoutes for data, runs, endpoints, jobs, reports, usage, and keys, described by one OpenAPI contract with cURL, Python, and JavaScript examples.
MCP serverEvery platform and API operation as a tool, over one remote URL, with sign-in or an API key. A result is the same output bundle the API returns.
IntegrationsAgent frameworks over MCP or one function-calling definition over REST, and workflow and data-stack tools built on the same OpenAPI contract.

Quick runs and endpoints
A quick run is one call that returns the full bundle for the tables you send and saves nothing. An endpoint is the persistent object: a base model, pinned dataset snapshots, a configuration, and a held-out report at a stable URL. You publish it once, serve it with a scoped key, refresh it when the source data changes, and upgrade it when a newer base ships. Each refresh and upgrade re-scores the held-out report, so the trail stays readable. See [quick runs and endpoints](https://www.ozercemkelahmet.com/articles/quick-runs-and-endpoints).

The held-out report
Every endpoint carries a held-out score measured on rows whose targets the model never saw. A report states its method, partition sizes, seed, baseline, and data snapshot, so the number says exactly what it claims. See [a score is only as good as its report](https://www.ozercemkelahmet.com/articles/a-score-is-only-as-good-as-its-report) and [snapshots keep numbers meaningful](https://www.ozercemkelahmet.com/articles/snapshots-keep-numbers-meaningful).

The MCP server
Schema is available natively in Claude, ChatGPT, Cursor, and any MCP client. Your AI hands Schema raw tables and databases, and gets back what the data is, how the sources relate, what is missing, and what can be predicted. Nothing is installed: you add one URL as a connector, or for Claude Code run `claude mcp add --transport http schema https://mcp.schemalabs.ai/mcp`. The setup guide is in the [MCP docs](https://docs.schemalabs.ai/mcp), and the [MCP page](https://www.ozercemkelahmet.com/model/mcp) on this site walks through it.

The documentation
The docs are organised as Get started (quickstart, introduction, authentication, models), How it works (data, outputs, endpoints, held-out reports), Integrations (agents and LLMs, MCP server, workflows and data stack), Product (platform, usage and billing), and Resources (changelog, troubleshooting, glossary, support). A full walk-through of the same material is under [Tabular foundation model](https://www.ozercemkelahmet.com/model) on this site.

## How many parameters does Schema-2 have?

Two numbers matter, and they describe different things.

MeasureSizeWhat it counts

First model of the class140 millionThe model introduced in the paper, trained on more than 2.3 million synthetic and real-world datasets.
Schema-2 coreMore than 1.5 billionThe shared body that reads tables: cell encoder, axial attention, and the Perceiver-style path.
Schema-2 merged checkpointAbout 2.18 billionThe core plus every head and adapter in one object, with the code embedded.

The merged checkpoint holds 23 keys and 1,783 tensors. At 16 bits its weights take about 4.4 GB, at 8 bits about 2.2 GB, and at 4 bits about 1.1 GB, before overhead.

## Architecture

Schema-2 is a transformer built for two-dimensional data. Each part answers a specific problem of tables. The [architecture](https://www.ozercemkelahmet.com/model/architecture) page explains them in full.

PartWhat it doesWhy it exists

[Cell encoding](https://www.ozercemkelahmet.com/model/cell-encoding)Turns each cell into a vector from its value, type, and position, with an explicit marker for a missing cell.Numbers, categories, dates, and text share one space, and a missing cell is an input, not an error.
[Axial attention](https://www.ozercemkelahmet.com/tools/axial-attention)Alternates attention along rows and along columns.Full attention over every cell grows with the square of the table size. Alternating layers cost far less and still reach every cell.
[Perceiver-style global path](https://www.ozercemkelahmet.com/tools/perceiver-io)A fixed set of latent vectors reads the whole table and writes back to the cells.Whole-table tasks need a table-level view, and cost grows only linearly with table size.
Zeroed column identityThe encoder never sees a column's name or identity.It closes a shortcut that would break on unfamiliar headers, and it is why the model works with random, stripped, or misleading names.
Shared representationOne internal representation feeds every head.The work is shared, so answers stay consistent with each other.
Task headsImputation network, semantic classification, prediction head, cross-table head.Small heads read the shared representation instead of one model per task.
Adapters and memoryAdapters that do not depend on the number of columns, with replay and regularization.New tasks can be added without erasing old ones.

## How it was pre-trained

Pre-training uses a very wide collection of real and synthetic tables with self-supervised objectives such as [masked cell modeling](https://www.ozercemkelahmet.com/tools/masked-cell-modeling). Synthetic tables come from a generator whose assumptions, the prior, the model absorbs. One lesson from this work is that the prior can be the real bottleneck: nine similarity-based decoders failed in the same way because the synthetic prior had turned some targets into XOR-like patterns, and changing the data fixed what changing the decoder could not. Details are on the [pre-training](https://www.ozercemkelahmet.com/model/pretraining) page.

## How it predicts without training on your table

Schema-2 predicts in context. The labelled rows of your table form a support set, and the prediction head compares each new row with them in a forward pass. No weights are updated. Classification returns probabilities for every class. Regression returns a whole distribution through a quantile head, with split-conformal calibration and isotonic correction so the intervals can be read as intervals. Anomaly detection uses three channels with a pseudo-anomaly selector and needs no labels. See [in-context prediction](https://www.ozercemkelahmet.com/model/in-context-prediction).

## What one checkpoint returns

A single pass over your tables returns one bundle with the same shape every time. An empty slice is a normal state, not an error. The [capabilities](https://www.ozercemkelahmet.com/model/capabilities) page covers each output.

OutputQuestion it answers

SectorWhat industry does this table belong to?
Column profileWhat is each column, and how much of it is missing?
Cross-table mapWhich columns and rows describe the same thing across tables?
ImputationWhat are the missing values likely to be?
PredictionsWhat will a target be, or which rows are unusual?
Synthetic dataWhat would a realistic table for this sector look like?
Held-out blockHow well does the model do on rows it did not see?

## Continual learning

New tasks are added through adapters that do not depend on the number of columns, a small replay buffer of raw rows (48 per task in the recipe that stayed), and elastic weight consolidation to limit drift. The buffer grows linearly, which is a known cost. See [continual learning for tables](https://www.ozercemkelahmet.com/model/continual-learning-for-tables).

## Compression and serving

The merged checkpoint was dumped at half precision, 8-bit, and 4-bit, and fidelity was measured against the full-precision model on the real tasks with [TurboQuant](https://www.ozercemkelahmet.com/tools/turboquant). A 4-bit weight takes a quarter of the space of a 16-bit one, and it can change answers, which is why the check exists. The benchmark numbers come from the same model that serves requests. See [compression and serving](https://www.ozercemkelahmet.com/model/compression-and-serving) and [one checkpoint, then compression](https://www.ozercemkelahmet.com/model/bench-unified-checkpoint).

## Dashboard
One checkpoint sits at the centre and each benchmark orbits it. Drag to rotate, or pick a benchmark from the list. Scores are left out on purpose.
Pick a benchmarkOne checkpoint, ten benchmarks

See the timelineRow predictionContinual learningAnomaly detectionProbabilistic regressionMetadata independenceSector identificationImputationEntity and schema matchingMissing-data robustnessOne checkpoint10benchmarks1unified checkpoint750missing-data settings504sector datasetsSize of each protocol (datasets, settings or models)Missing-data gridMissing-data grid: 750750Sector identificationSector identification: 504504Probabilistic regressionProbabilistic regression: 102102Imputation (real)Imputation (real): 2020Size of each protocol (datasets, settings or models) Counts are datasets or settings, so only compare within a row.Field size in the two ranked comparisonsProbabilistic regression, modelsProbabilistic regression, models: 5050Anomaly detection, methodsAnomaly detection, methods: 1313Field size in the two ranked comparisons

## What was measured

Each capability has a benchmark story with its protocol, what the model achieved, and the limits. Scores are left out on purpose, because they depend on the harness, the fold count, and the snapshot date. Each story states what it measured and where the model stayed behind.

StoryScope

[Row-level prediction](https://www.ozercemkelahmet.com/model/bench-row-prediction)Classification and regression boards against tuned rivals.
[Imputation](https://www.ozercemkelahmet.com/model/bench-imputation)Three missingness mechanisms.
[Anomaly detection](https://www.ozercemkelahmet.com/model/bench-anomaly-detection)Thirteen methods compared.
[Probabilistic regression](https://www.ozercemkelahmet.com/model/bench-probabilistic-regression)102 regression datasets and 50 models.
[Continual learning](https://www.ozercemkelahmet.com/model/bench-continual-learning)Retention across sequential tasks.
[Metadata independence](https://www.ozercemkelahmet.com/model/bench-metadata-independence)Column names removed or replaced with noise.
[Blind sector identification](https://www.ozercemkelahmet.com/model/bench-sector-identification)504 real datasets with column names zeroed.
[Entity and schema matching](https://www.ozercemkelahmet.com/model/bench-entity-schema-matching)Keyless, name-blind matching.
[Missing-data robustness](https://www.ozercemkelahmet.com/model/bench-missing-data-robustness)A grid of 750 settings.
[Unified checkpoint](https://www.ozercemkelahmet.com/model/bench-unified-checkpoint)All capabilities in one object, then quantized.

Every run is checked for contamination against the training corpus with an identifier blocklist and a distributional near-duplicate check. See [evaluation](https://www.ozercemkelahmet.com/model/evaluation) and [benchmarks](https://www.ozercemkelahmet.com/model/benchmarks).

## Limits

Regression and multiclass prediction stayed behind the leaders in my measurements. Gradient-boosted trees remain strong on a single, stable dataset with abundant labels, and a model of this size costs more to host. The [limitations](https://www.ozercemkelahmet.com/model/limitations) page lists what does not work yet.

## Frequently asked questions

How many parameters does Schema-2 have?
The core has more than 1.5 billion parameters. With every head and adapter merged into one checkpoint, the total is about 2.18 billion.

What is Schema-2?
A large tabular foundation model, and a Data Language Model, that reads raw tables and returns sector, column profile, cross-table map, imputation, predictions, synthetic data, and a held-out score in one pass.

Does Schema-2 use column names?
No. Column embeddings are always zeroed, so the encoder sees values and their relations, never a column's identity.

Does it train on my data?
No. It predicts in context from the labelled rows of your table, and no weights are updated.

Can it be compressed?
Yes. It was stored at half precision, 8-bit, and 4-bit, with fidelity measured against the full-precision model on the real tasks.

Where is the research?
In the paper Data Language Models: A New Foundation Model Class for Tabular Data, [arXiv:2605.06290](https://arxiv.org/abs/2605.06290), and on the [research](https://www.ozercemkelahmet.com/model/research) page.