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.
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.
| Link | What it is |
|---|---|
| www.schemalabs.ai | The product site: the model, the model registry, research, solutions, and the platform entry. |
| docs.schemalabs.ai | The documentation and API reference: quickstart, authentication, models, data, outputs, endpoints, held-out reports, integrations, and troubleshooting. |
| platform.schemalabs.ai | The web platform: dashboard, data, quick runs, workspace, endpoints, reports, chat, and API keys. |
| MCP server | One remote server at https://mcp.schemalabs.ai/mcp for Claude, ChatGPT, Cursor, VS Code, Gemini CLI, and any MCP client. |
| Model registry | The model card of record: intended use, training data, evaluation, lifecycle, and known limitations. |
| arXiv: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.
| Surface | What it does |
|---|---|
| Platform | Dashboard, 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 API | Routes for data, runs, endpoints, jobs, reports, usage, and keys, described by one OpenAPI contract with cURL, Python, and JavaScript examples. |
| MCP server | Every 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. |
| Integrations | Agent 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.
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 and 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, and the MCP page 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 on this site.
How many parameters does Schema-2 have?
Two numbers matter, and they describe different things.
| Measure | Size | What it counts |
|---|---|---|
| First model of the class | 140 million | The model introduced in the paper, trained on more than 2.3 million synthetic and real-world datasets. |
| Schema-2 core | More than 1.5 billion | The shared body that reads tables: cell encoder, axial attention, and the Perceiver-style path. |
| Schema-2 merged checkpoint | About 2.18 billion | The 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 page explains them in full.
| Part | What it does | Why it exists |
|---|---|---|
| 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 | 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 | 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 identity | The 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 representation | One internal representation feeds every head. | The work is shared, so answers stay consistent with each other. |
| Task heads | Imputation network, semantic classification, prediction head, cross-table head. | Small heads read the shared representation instead of one model per task. |
| Adapters and memory | Adapters 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. 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 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.
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 page covers each output.
| Output | Question it answers |
|---|---|
| Sector | What industry does this table belong to? |
| Column profile | What is each column, and how much of it is missing? |
| Cross-table map | Which columns and rows describe the same thing across tables? |
| Imputation | What are the missing values likely to be? |
| Predictions | What will a target be, or which rows are unusual? |
| Synthetic data | What would a realistic table for this sector look like? |
| Held-out block | How 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.
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. 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 and one checkpoint, then compression.
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.
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.
| Story | Scope |
|---|---|
| Row-level prediction | Classification and regression boards against tuned rivals. |
| Imputation | Three missingness mechanisms. |
| Anomaly detection | Thirteen methods compared. |
| Probabilistic regression | 102 regression datasets and 50 models. |
| Continual learning | Retention across sequential tasks. |
| Metadata independence | Column names removed or replaced with noise. |
| Blind sector identification | 504 real datasets with column names zeroed. |
| Entity and schema matching | Keyless, name-blind matching. |
| Missing-data robustness | A grid of 750 settings. |
| 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 and 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 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, and on the research page.