Thinking mode

TabPFN-3.5-Thinking is our most accurate model, especially on grouped and temporal data. It uses more compute during fitting to improve prediction quality, and the fitted model can then be reused for repeated predictions. It handles mixed numerical, categorical, and text features. See the TabPFN-3.5 technical report for benchmark results.

Available through tabpfn-client, the REST API, and enterprise deployments.

When to use it

Use Thinking mode when small gains in prediction quality justify more time spent fitting, such as in finance or healthcare.

Quickstart

Thinking mode uses TabPFN-3.5-Thinking by default. You can also select TabPFN-3-Thinking.

Classification
Regression

from tabpfn_client import TabPFNClassifier

clf = TabPFNClassifier(
    thinking_mode=True,
    thinking_effort="high",
    thinking_metric="accuracy",
)
clf.fit(X_train, y_train)
preds = clf.predict(X_test)
probs = clf.predict_proba(X_test)

from tabpfn_client import TabPFNRegressor

reg = TabPFNRegressor(
    thinking_mode=True,
    thinking_effort="high",
    thinking_metric="rmse",
)
reg.fit(X_train, y_train)
preds = reg.predict(X_test)

Choosing the model

Thinking mode uses TabPFN-3.5-Thinking by default. To select a version explicitly, use ModelVersion.V3_5 for TabPFN-3.5-Thinking or ModelVersion.V3 for TabPFN-3-Thinking:

TabPFN-3.5-Thinking (default)
TabPFN-3-Thinking

from tabpfn_client import TabPFNClassifier
from tabpfn_client.api_models import ModelVersion

clf = TabPFNClassifier.create_default_for_version(ModelVersion.V3_5, thinking_mode=True)
clf.fit(X_train, y_train)

from tabpfn_client import TabPFNClassifier
from tabpfn_client.api_models import ModelVersion

clf = TabPFNClassifier.create_default_for_version(ModelVersion.V3, thinking_mode=True)
clf.fit(X_train, y_train)

`model_path`	Model with Thinking enabled
unset (default) or `"v3.5_default"`	TabPFN-3.5-Thinking
`"v3_default"`	TabPFN-3-Thinking

See Selecting Model Version for more details.

Choosing effort and metric

Effort controls how much compute is spent during fitting. The metric defines what to optimize.

`thinking_effort`

Effort	When to choose it
`"medium"` (default)	Balance prediction quality and fit time.
`"high"`	Prioritize prediction quality when longer fits are acceptable.

You can also set thinking_timeout_s to cap the time spent fitting.

`thinking_metric`

Choose a metric that matches how you evaluate predictions. Common choices:

Task	Metric	When to choose it
Classification	`"accuracy"`	Maximize the proportion of correct class predictions.
Classification	`"log_loss"`	Optimize predicted class probabilities.
Binary classification	`"roc_auc"`	Rank positive examples above negative ones across decision thresholds.
Regression	`"rmse"`	Penalize large prediction errors more heavily.
Regression	`"mae"`	Minimize average absolute error, with less sensitivity to large errors.

Grouped and time-ordered rows

Requires tabpfn-client 0.6.0 or later.

Specifying group and time columns can improve predictions on data with related rows or a time sequence, such as repeat patient visits, customer transactions, or sensor readings over time. Use the parameters below to identify these relationships.

Parameter	What it does
`group_col`	Column, or list of columns, that identifies groups of related rows, such as a patient or session ID.
`time_col`	Temporal feature, stored as datetimes or numbers.
`group_time_col`	Temporal feature within grouped data, such as transaction time for each customer.

Code sample

import numpy as np
import pandas as pd
from sklearn.model_selection import GroupShuffleSplit
from tabpfn_client import TabPFNClassifier

rng = np.random.default_rng(0)
n_rows = 600
X = pd.DataFrame(
    {
        "patient_id": rng.integers(0, 120, n_rows),
        "age": rng.integers(20, 90, n_rows),
        "heart_rate": rng.normal(75, 12, n_rows),
        "blood_pressure": rng.normal(125, 15, n_rows),
    }
)
y = (X["heart_rate"] + rng.normal(0, 10, n_rows) > 80).astype(int)

# Hold out whole patients, so no test patient appears in the training data.
splitter = GroupShuffleSplit(n_splits=1, test_size=0.2, random_state=0)
train_idx, test_idx = next(splitter.split(X, y, groups=X["patient_id"]))
X_train, X_test = X.iloc[train_idx], X.iloc[test_idx]
y_train = y.iloc[train_idx]

clf = TabPFNClassifier(thinking_mode=True, group_col="patient_id")
clf.fit(X_train, y_train)
probs = clf.predict_proba(X_test)  # X_test keeps the patient_id column

Rules, checked by the client before any data is uploaded. A violation raises ValueError:

The columns work only with thinking mode.
X passed to fit and to predict must be a pandas DataFrame that holds every named column. Pass column names, not indices.
group_col and time_col cannot be combined.
group_time_col requires group_col.

Save and load

Requires tabpfn-client 0.6.0 or later.

Save a thinking fit once and load it later, in another process or on another machine, to predict without refitting:

from tabpfn_client import TabPFNClassifier

clf = TabPFNClassifier(thinking_mode=True)
clf.fit(X_train, y_train)
clf.save_model("model.json")

# Later, in another process or on another machine:
clf = TabPFNClassifier.load_model("model.json")
clf.predict(X_test)

The file references the fit on Prior Labs servers and holds no training data. Load it with the same account that ran the fit.

REST API

Call POST /tabpfn/fit with the thinking parameters in the JSON body:

{
  "train_set_upload_id": "<your-upload-id>",
  "task": "classification",
  "thinking_effort": "high",
  "thinking_timeout_s": 300,
  "thinking_effort_metric": "log_loss"
}

See the API reference for the full endpoint documentation and upload flow.

Parameters

Parameter	Type	Default	Description
`thinking_mode`	`bool`	`False`	Enable thinking mode. Setting `thinking_effort` also enables it.
`model_path`	`str`	`None`	Defaults to TabPFN-3.5-Thinking when Thinking is enabled (see Choosing the model)
`thinking_effort`	`"medium"` or `"high"`	`None`	Uses `"medium"` when Thinking is enabled. See effort guidance.
`thinking_timeout_s`	`float`	`None`	Wall-clock time budget in seconds
`thinking_metric`	`str`	`None`	Target metric to optimize (see metric guidance)
`group_col`	`str` or `list[str]`	`None`	Column(s) of `X` that identify groups of related rows (see Grouped and time-ordered rows)
`time_col`	`str`	`None`	Column of `X` that holds time. Cannot be combined with `group_col`.
`group_time_col`	`str`	`None`	Temporal feature within grouped data, such as transaction time for each customer. Requires `group_col`.

On the REST API, the metric parameter is called thinking_effort_metric.

Limits

Thinking fits use more compute than standard fits and consume tokens from the same daily and monthly budgets as predictions. Higher effort increases token usage. Reuse a fitted model for repeated predictions to avoid paying for another fit. See API metering for token charges and budgets, and API rate limits for request limits.

TabPFN-3.5 changelog

Release notes and upgrade guidance for TabPFN-3.5.

API metering

Token charges, budgets, and usage tracking.

Classification

Binary and multi-class classification guide.

Regression

Point estimates, quantiles, and full distributions.

Getting Started

Metering and rate limits

Capabilities

Agentic

Integrations

Troubleshooting

TabPFN in Action

Customer References

Changelog

When to use it

Quickstart

Choosing the model

Choosing effort and metric

`thinking_effort`

`thinking_metric`

Grouped and time-ordered rows

Code sample

Save and load

REST API

Parameters

Limits

TabPFN-3.5 changelog

API metering

Classification

Regression

​When to use it

​Quickstart

​Choosing the model

​Choosing effort and metric

​thinking_effort

​thinking_metric

​Grouped and time-ordered rows

​Code sample

​Save and load

​REST API

​Parameters

​Limits

TabPFN-3.5 changelog

API metering

Classification

Regression

When to use it

Quickstart

Choosing the model

Choosing effort and metric

`thinking_effort`

`thinking_metric`

Grouped and time-ordered rows

Code sample

Save and load

REST API

Parameters

Limits