GPT-5.6

Overview

GPT-5.6 is a late release in OpenAI's GPT-5 family of large language models. It is the previous generation relative to GPT-6, and it remains widely deployed because many products were built, tested and tuned on it. Teams use it for general language tasks and as a stable baseline when they compare newer models.

For tabular data, GPT-5.6 behaves like other text-first language models. It reads a table as text and reasons with language skills. It writes SQL, explains results, names columns and drafts reports well. It is not designed to learn from millions of raw rows. That job belongs to models pre-trained on tables, described at /model/research. Used together, the language model handles words and the tabular model handles numbers.

What it is

GPT-5.6 is a generative pre-trained transformer. It was trained to predict the next token in text and code, then tuned to follow instructions, use tools and respect safety rules. It belongs to a family, so a given product may offer several sizes or reasoning settings under the same family name.

Public detail about internal size, data and training recipe is limited. This article therefore describes the general class of model and the practical points of using it, rather than private facts.

Why a previous-generation model still matters

• Many production prompts were tuned on it and still work.
• Its behavior is well known, so regressions are easy to spot.
• It may cost less than a newer flagship for the same task.
• Pinned versions give reproducible results for audits.
• It acts as a control in A/B tests against newer models.

Typical capabilities

• Instruction following and long-form writing.
• Code generation, explanation and review.
• Tool and function calling with JSON arguments.
• Schema-constrained output.
• Summarization, extraction and classification.
• Question answering over text given in the prompt.

Typical limits

• Fluent but wrong answers can occur.
• Arithmetic over long columns is unreliable without tools.
• Context size is finite, so large tables do not fit.
• It does not know your private data unless you supply it.

Where it came from

The GPT line began with a 2018 paper on generative pre-training. The 2017 paper "Attention Is All You Need" introduced the transformer used in these models. The 2020 GPT-3 paper showed that scale brings in-context learning. Later work added instruction tuning and learning from human feedback, then tool use, longer context, image input and reasoning modes.

The GPT-5 family is one stage in that path. A late point release such as GPT-5.6 usually refines quality, speed, safety and tool use without changing the core design. When a new generation arrives, the older line moves into a supporting role: still available, still used, gradually replaced.

The life cycle of a model line

1. A flagship is released and adopted.
2. Point releases improve it.
3. A new generation arrives.
4. The older line is kept for compatibility and lower cost.
5. Providers announce a retirement date.
6. Teams migrate, using test sets to check for regressions.

Knowing this cycle helps you plan. Treat any model name in your code as something that will change.

How it works

The description below is of the general design. Each step has an everyday picture.

Step 1: Tokenize

Text is cut into tokens. A tokenizer is like a set of stamps; any sentence is made by pressing stamps in a row. Numbers and rare words break into several stamps. See BPE.

Step 2: Embed

Each token becomes a vector of numbers. Similar meanings sit near each other, like pins on a map of ideas.

Step 3: Attend

Layers of attention let each token look at all earlier tokens and decide which matter. Picture a reader who underlines the lines they will need later.

Step 4: Predict

The model assigns a probability to each possible next token and picks one. Repeating this builds the answer. Temperature controls how adventurous the pick is.

Step 5: Pre-train

The model reads a huge collection of text and code, and learns by guessing the next token. Mistakes adjust billions of internal weights. This is like a student who reads a library and gradually gets a feel for language.

Step 6: Post-train

Methods such as SFT, RLHF and DPO teach the model to answer helpfully and refuse unsafe requests.

Step 7: Use tools

At run time, the model can emit a tool call. Your code executes it and returns a result. The model continues with that result in view. See Function calling.

How a table is read

A table in a prompt is a string. Row and column structure is implied by separators. A model must align each value with its header by position in the text. Clean formats such as CSV with a header row or Markdown tables help. Wide tables with many similar columns are where alignment errors creep in.

Key concepts and terms

A worked example

This example migrates a classification prompt from GPT-5.6 to a newer model while keeping scores comparable. It follows the safe path: freeze a test set, run both, compare.

The task

Classify short support notes into one of four labels: billing, delivery, product, other. The output must be JSON.

The prompt

Classify the note into exactly one label: billing, delivery, product, other.
Return JSON: {"label": "<label>"}
Note: "My parcel never arrived and tracking is stuck."

The comparison harness

import json

LABELS = {"billing", "delivery", "product", "other"}

def classify(client, model, note):
    reply = client.generate(
        model=model,
        input=PROMPT.format(note=note),
        temperature=0,
    )
    try:
        data = json.loads(reply.text)
    except json.JSONDecodeError:
        return "invalid"
    return data.get("label") if data.get("label") in LABELS else "invalid"

def score(client, model, test_set):
    hits = invalid = 0
    for note, gold in test_set:
        pred = classify(client, model, note)
        hits += pred == gold
        invalid += pred == "invalid"
    n = len(test_set)
    return {"accuracy": hits / n, "invalid_rate": invalid / n}

old = score(client, "gpt-5.6", test_set)
new = score(client, "gpt-6", test_set)
print(old, new)

Reading the result

Suppose the test set has 200 notes. If the old model gets 170 right, accuracy is 170 / 200 = 0.85. If the new model gets 176 right, accuracy is 0.88. A gain of three points on 200 notes is within the noise of a small set, so look at the invalid rate, the cost and the per-label errors before deciding. Larger sets give firmer answers.

Cost check

The decision rests on the whole row set, not on one line.

Linking to a tabular model

If the notes also carry numeric fields, such as order value and days late, a tabular predictor such as TabICL can learn which combination predicts an escalation. The language model reads the note text, and the tabular model reads the numbers. A final rule merges both.

A second example: routing by difficulty

A router sends easy requests to a cheaper model and hard ones to a stronger one. The sketch below uses a placeholder scorer.

def difficulty(request):
    # placeholder heuristic: long input or the word "analyze" is hard
    return "hard" if len(request) > 800 or "analyze" in request.lower() else "easy"

ROUTES = {"easy": "gemini-3-8-flash", "hard": "gpt-5-6"}

def answer(client, request):
    model = ROUTES[difficulty(request)]
    return client.generate(model=model, input=request, temperature=0).text

What to notice

• The route table is data, so a migration is a one-line change.
• The heuristic is crude. In practice, measure which requests the cheap model fails and refine the rule.
• Log the route taken so you can audit cost and quality later.

Numeric walk-through: per-task cost

Suppose a task uses 1,500 input tokens and 300 output tokens. If you run 100,000 such tasks per month, that is 150 million input tokens and 30 million output tokens. Multiply by the unit rates in your own agreement to get the bill. If a cheaper model passes your test set, the same volume costs less. The point of the arithmetic is to make the saving visible before you migrate, not after.

Test set design

Strengths and limitations

Strengths

• Mature and well understood in production.
• Strong general language and coding skills.
• Good tool and schema support.
• A stable baseline for A/B tests.
• Often lower cost than the newest flagship.

Limitations

• Not the newest generation, so some tasks may score lower than on a newer model.
• A retirement date will eventually force migration.
• Text-first handling of tables limits precision and scale.
• Hallucination remains possible.
• Hosted use sends data outside your network.

Table-specific limits

How it compares with alternatives

No single row wins every task. A routing layer can send each request type to the model that does it best at the lowest cost.

Role in tabular foundation models

A tabular foundation model is pre-trained on many tables so it can predict, impute or flag anomalies on a new table with little training. Its design is covered at /model/architecture, and results at /model/benchmarks. GPT-5.6 is a different kind of model, but it touches this field in several concrete ways.

Grid versus string

A tabular model keeps the grid. Rows are samples, columns are features, and every cell has a type. It can attend across rows and across columns, as in Axial attention. GPT-5.6 sees a string and must rebuild the grid from separators. That costs tokens and can misalign cells.

Mixed types

Tables mix numbers, categories, dates and text. A tabular model gives each type its own encoding. A language model tokenizes all of them as text. For numbers, this loses scale and ordering unless the model infers them. For categories with many levels, a tabular model can use learned embeddings, while a language model sees only words.

Missing values

A tabular model can mask a cell and learn to predict it, which is the idea behind Masked cell modeling and Imputation networks. A language model sees "NaN", "n/a", "-" and empty strings as different tokens and may treat them differently. Normalize missing codes before sending a table to GPT-5.6.

No column names

Raw exports often use names like c1 and c2. A tabular foundation model can work from values and distributions. GPT-5.6 leans on names. It can still help when names are present, by guessing that dob means date of birth, and it can propose readable names for you to confirm.

Synthetic pre-training

Tabular foundation models are commonly pre-trained on large numbers of synthetic tables built from random generating processes, so they learn the skill of fitting a table given as context. See Synthetic data generation. A language model learns tables only as part of general text.

In-context learning

Both use it. GPT-5.6 learns from a few examples in text. A tabular model reads the full training table as context and predicts test rows in one pass. See TabPFN.

Continual learning

A hosted language model is not retrained per customer. Fresh facts arrive by retrieval. A tabular model can be updated with replay or regularization to avoid forgetting; see Experience replay and EWC.

Anomaly detection and sector classification

For row outliers, a tabular model scores the numbers; see Anomaly detection. GPT-5.6 can explain the flag in words. For sector or semantic classification of a whole table, GPT-5.6 does well when headers are readable, while a model with Semantic sector heads can work when they are not. Comparing both is a cheap safety check.

Where it fits in a pipeline

Practical guidance and best practices

Pin and test

• Pin the model version where the service allows it.
• Keep a frozen test set of real tasks.
• Re-run the set whenever you change the prompt or model.
• Store results by date so trends are visible.

Plan the migration

• Read the provider's deprecation notice early.
• Run the old and new model side by side on your test set.
• Change one thing at a time: model first, then prompt.
• Roll out to a small share of traffic, then expand.
• Keep the old route available for a short period as a fallback.

Prompt hygiene

• Put the output format at the end of the prompt, where it is fresh.
• Use a schema for anything code will parse.
• Keep examples short and consistent.
• Avoid relying on quirks of one version.

Tables

• Send header, types and a small sample, not the entire table.
• Use code for sums and counts.
• Convert missing codes to one marker before the call.
• Mask personal fields. See Data tokenization.

Cost

• Use the smallest model that passes your test set.
• Cache static prompt parts if supported.
• Measure tokens per task, not only price per token.
• Set limits. See Cost and latency budgets.

Safety

• Treat retrieved text as untrusted. See Prompt injection defense.
• Check outputs with Guardrails.
• Keep a human in the loop for high-impact actions. See Human-in-the-loop.

A rollout plan for a model change

1. Freeze the test set and record current scores.
2. Run the candidate and compare every metric, not only accuracy.
3. Read twenty failures by hand.
4. Send five percent of traffic to the candidate.
5. Watch error rates, latency and user feedback for a week.
6. Expand in steps, keeping the old route ready.
7. Remove the old route only after a quiet period.

Configuration sketch

routes:
  default:
    model: gpt-5-6
    temperature: 0
  candidate:
    model: gpt-6
    traffic_share: 0.05
checks:
  json_schema: support_label_v1
  max_latency_ms: 4000
rollback:
  on_error_rate_above: 0.03

Documentation habits

• Write down why each prompt line exists.
• Note known failure cases beside the test set.
• Record the date and model version of every evaluation.
• Keep a short changelog of prompt edits.
• Share results with the people who own the downstream system.

Handling tables safely before the call

Preparing a table takes a few steps, and each step is simple.

1. Profile the columns. Count missing cells, distinct values and obvious types.
2. Normalize missing codes to one marker, such as an empty cell.
3. Drop columns the task does not need. Fewer columns mean fewer tokens and fewer chances to misalign.
4. Mask or tokenize personal fields.
5. Sample rows in a way that keeps rare classes visible.
6. Render the sample as CSV or Markdown with a header row.
7. State units and date formats in one line above the table.

import pandas as pd

df = pd.read_csv("export.csv")
df = df.replace({"N/A": None, "-": None, "null": None})
df = df.drop(columns=["internal_note"])
sample = df.sample(n=min(40, len(df)), random_state=0)
text = sample.to_csv(index=False)

Everyday analogy for sampling

Reading forty rows to understand a million-row table is like tasting a spoonful of soup to judge the pot. It works only if the soup is stirred. Random sampling is the stirring. If the pot has a rare ingredient, such as a fraud class, take a larger spoon of that part on purpose.

Quality checks on model answers

• Recompute any number the model states, using code.
• Check that every cited column exists.
• Check that generated SQL parses before running it.
• Compare answers across two models on a sample, and read the disagreements.
• Keep a list of questions the model has answered wrongly before, and test it each time.

Reviewing a failure

When a case fails, ask four questions in order. Was the input clear? Was the instruction clear? Did the model lack a fact it needed? Did the output format break? Most failures trace to the first two, and they are fixed by editing the prompt, not by changing models.

When to stay on the older model

• The task passes your test set and the cost is acceptable.
• A migration would need a long re-validation by a regulator or auditor.
• The newer model changes output style in ways your parsers do not handle yet.
• The retirement date is far enough away to schedule the move calmly.

Common mistakes

• Switching models without a test set.
• Assuming a newer model is better on every task.
• Hard-coding a model name in many places, so migration becomes painful.
• Leaving the old model with no end-of-life plan.
• Judging quality by a handful of examples.
• Pasting large tables and trusting sums.
• Using a language model to predict on a big table instead of a trained predictor.
• Ignoring format drift, where a new model returns slightly different JSON.
• Forgetting to re-tune temperature and length limits after switching.
• Skipping a rollback path.

Frequently asked questions

What is GPT-5.6?

GPT-5.6 is a late release in OpenAI's GPT-5 family of large language models. It is the previous generation relative to GPT-6 and is still used in many products as a stable baseline. Its internal details are not fully public, so teams judge it by testing on their own tasks.

Should I move from GPT-5.6 to GPT-6?

Often yes in time, but only after testing. Run both on a frozen test set of your real tasks, compare accuracy, invalid output rate, cost and latency, and roll out gradually. Some tasks gain from a newer model and some do not.

Is GPT-5.6 good at tables?

It is good at reading small tables as text, writing SQL, explaining results and naming columns. It is weak at exact arithmetic over long columns and at learning from very large tables. For prediction on large tables, use a trained model such as a tabular foundation model.

Can it return reliable JSON?

Usually, if you give a schema, keep temperature low and validate in code. When validation fails, retry once with the error message. A structured output mode, where offered, reduces failures further.

Why do people still use older model lines?

Prompts and tests are tuned to them, behavior is known, cost may be lower and versions can be pinned for audits. Moving takes work, so teams migrate when the gain justifies it or when a retirement date forces it.

How do I avoid lock-in to one model?

Wrap model calls behind one function, keep prompts in files, store test sets, and avoid features that only one provider offers unless the benefit is clear. Then switching means changing a name and re-running the tests.

Does it learn from my data over time?

A hosted model does not change its weights per customer in normal use. To make it aware of your data, supply the data or retrieved passages in the prompt. Check the provider terms for how your prompts are stored.

How does it relate to tabular foundation models?

They are complementary. GPT-5.6 handles language: questions, SQL, explanations and column naming. A tabular foundation model handles the grid: predicting labels, filling missing cells and scoring outliers. A good system lets each do what it is built for.

How many rows can I paste into it?

It depends on the context window and your cost limit, but a few hundred rows of a narrow table is a practical ceiling for casual use. Beyond that, send a summary, a sample or a query result instead.

Glossary

• Baseline: a reference result used for comparison.
• Context window: maximum tokens per request.
• Deprecation: announced retirement of a model version.
• Embedding: a vector that represents a token.
• Family: a named line of related models.
• Hallucination: fluent but false output.
• In-context learning: learning from examples in the prompt.
• Pinned version: a fixed version used for repeatable results.
• Point release: a small version step inside a family.
• Regression: a quality drop after a change.
• Routing: choosing a model per request.
• Structured output: output that matches a schema.
• Temperature: a randomness setting.
• Token: a small unit of text.
• Tool call: a structured request for external code.
• Tabular foundation model: a model pre-trained on tables.

Summary

GPT-5.6 is a late release in OpenAI's GPT-5 family. It is the previous generation next to GPT-6, and it stays useful as a stable, well-understood baseline and a lower-cost option. It reads tables as text, which suits small samples, SQL writing and explanation, but not large-scale prediction.

Treat the model name as a setting that will change. Pin versions, keep a frozen test set, migrate by side-by-side comparison, and keep a rollback path. For learning from raw rows, pair it with tabular foundation models, described at /model/research, /model/architecture and /model/benchmarks.

Related

It belongs to Frontier models in my stack, under LLMs, retrieval, and evaluation. Others in the same group: