What is GPT and Why It Matters Today

GPT stands for generative pre-trained transformer. That is a technical description of how a certain kind of AI model is built, and it is also OpenAI's product name - which is the source of most of the confusion around the term.

Understanding the three words in that acronym explains almost everything about how these tools behave: what they are good at, why they sometimes state false things with complete confidence, and why they do not know what happened last week. It is worth twenty minutes because it changes how you use them.

This guide covers what the term means, how the models work without the mathematics, why they get things wrong in the specific way they do, and how GPT relates to ChatGPT and to the other models you will have heard of.

A GPT is a type of AI model trained on very large amounts of text, which produces new text by repeatedly predicting what should come next. You give it some words, it works out what most plausibly follows, adds that, and repeats. Everything these systems appear to do - answering questions, writing code, summarising a document, holding a conversation - emerges from that one operation performed extremely well.

The word carries two meanings and people rarely separate them. As a technical description, generative pre-trained transformer covers a whole architecture that most modern language models share. As a brand, GPT is what OpenAI calls its own models. So it is true both that almost every well-known AI assistant is built on this architecture and that only OpenAI's are called GPT, which is why the sentence is it a GPT? has two correct and opposite answers.

There is a third use worth knowing about: the small custom assistants some platforms let you configure and share are also called GPTs. Those are not new models. They are the same underlying model with instructions attached, which matters if somebody tells you they have built one.

Each of the three words describes something that shapes how the model behaves in practice.

• Generative. It produces new text rather than selecting from a stored set of answers. There is no database of responses inside it to look things up in. Every sentence it gives you is constructed on the spot, which is why the same question twice can produce two different answers.
• Pre-trained. The learning happened before you ever typed anything, on a large body of text collected up to a particular date. That date is the training cutoff, and it is why a model can be fluent about a subject and entirely unaware of something that happened last month. It is also why the model does not learn from your conversation - unless the product around it is deliberately storing things, the next session starts from nothing.
• Transformer. The architecture, introduced in research published in 2017, that made all of this work. Its key idea is attention: when processing any part of the text, the model weighs how relevant every other part is. That is what lets it keep track of what a pronoun refers to across several paragraphs, and it is the reason these models handle context far better than anything that came before them.

The middle word is the one that catches people out most often. A great deal of frustration with these tools comes from expecting a system that learns from you and looks things up, when what you have is a system that finished learning some time ago and is reconstructing from memory.

The model does not work with words exactly. It works with tokens - pieces of words, roughly four characters on average in English. Understanding becomes a chain of these pieces rather than one unit. This is a small detail with visible consequences: it is part of why models have historically struggled to count letters in a word or reverse a string, because they are not seeing the letters the way you are.

During training, the model is shown enormous quantities of text with parts hidden, and asked to predict what was hidden. Getting it wrong adjusts its internal parameters very slightly. Repeat that across a large fraction of the written internet and the adjustments accumulate into something that has, in effect, absorbed the statistical shape of how language is used - including how explanations are structured, how code is written, and how arguments are made.

When you send a message, that message plus the conversation so far becomes the context. The model predicts the next token, appends it, and repeats until it decides the response is finished. Nothing is retrieved and nothing is reasoned about in the way a person would - though newer models are trained to produce intermediate working before answering, which improves results on problems that need several steps.

After the main training, models go through further stages that shape their behaviour rather than their knowledge - being taught to follow instructions, to be helpful, and to decline certain requests. This is why two models trained on similar material can feel so different to use. Much of what you experience as a model's personality comes from this stage rather than from the underlying architecture.

This is the most useful thing to understand about these tools, and it follows directly from how they work. The model is producing a plausible continuation of the text so far. When you ask a factual question, a plausible continuation is a plausible-sounding fact - and the model has no internal marker distinguishing something it absorbed accurately from something it is constructing now. Both feel identical from the inside, because mechanically they are the same operation.

That explains a set of behaviours that otherwise look like separate bugs. A confidently invented citation, a plausible statistic with no source, a court case that never happened, a function in a library that does not exist. None of these is the model lying or malfunctioning. Each is the model doing exactly what it does, on a question where the plausible answer and the true answer are not the same thing.

It also explains where the failures cluster. They are most common with specific facts, names, numbers, dates and citations - anything where being nearly right is the same as being wrong. They are least common with structure, explanation, rephrasing and reasoning about material you supplied, because there the plausible answer generally is the right one.

• Confidence is not a signal. The tone is identical whether the answer is right or invented, so it carries no information about reliability. Verify anything that matters, regardless of how certain it sounded.
• Give it the material rather than asking it to recall. A model reading a document you pasted is reliable in a way that the same model recalling that document is not. This one habit removes most of the risk.
• Ask what it cannot verify. Adding tell me which parts of this you are uncertain about costs one clause and surfaces the weak points more often than people expect.
• Tools change the picture. A model that can search the web or run code is doing something different from recalling: it is fetching or computing, and then describing the result. That is far more reliable, but only for the part it actually fetched.

GPT is the model. ChatGPT is the product built around it - the interface, the conversation history, the file uploads, the safety layer, the account. The same relationship as between an engine and a car. You can put a different engine in, and OpenAI has done exactly that several times while the product kept its name.

The harder question is whether Claude, Gemini, Grok or DeepSeek are GPTs. Technically they are all generative pre-trained transformers - same architecture family, same basic training approach, same three words apply. But none of them is called a GPT, because that is OpenAI's brand rather than a neutral label. Saying Claude is a GPT is a bit like calling any vacuum cleaner a Hoover: technically understood, formally wrong.

In practice the useful distinction is not architecture, which is largely shared, but who made it and what it is called:

This matters more than it sounds. People often assume all these tools are the same thing with different logos, and conclude that the choice is arbitrary. They do share an architecture - but they were trained on different material, tuned by different teams with different priorities, and behave noticeably differently on the same request. Our guides to Gemini, Grok and DeepSeek cover what distinguishes each one.

The uses that hold up are the ones aligned with what the model is doing mechanically. Transformation, explanation and structure work well. Recall of specific facts works badly. Almost every disappointed user is on the wrong side of that line.

• Turning one form of text into another. Notes into a summary, a transcript into decisions and actions, a paragraph into three shorter versions, English into another language. The source material is in front of it, so this is the most reliable category there is.
• Explaining something at your level. Ask for the same concept three different ways until one lands. This is where these tools are genuinely better than a search engine, because they will adapt the explanation rather than handing you the same page again.
• Producing options you choose between. Ten subject lines, six ways to structure an argument, four names. The model is better at generating a range than at picking the right one, and you are better at picking than at generating.
• First drafts and code you will review. Getting past an empty page is worth a great deal, provided the output is treated as material to edit rather than as finished work. Code in particular can be syntactically perfect and semantically wrong, so it needs running rather than trusting.
• Being argued with. Ask what is wrong with your plan, or for the strongest case against a position you hold. This is the most underused capability and often the most valuable, because it costs nothing and occasionally saves a great deal.

Our best ChatGPT prompts collection covers the twenty-five worth memorising, and the wider ChatGPT prompts guide covers technique.

Version numbers change every few months and any article naming them is out of date shortly after publication. The directions of travel are more durable than the releases, and there are four worth knowing.

• Models that work before answering. Rather than producing a response immediately, reasoning-tier models generate intermediate steps first. This costs time and meaningfully improves results on anything requiring several stages, which is why they are worth selecting deliberately for hard problems.
• Text is no longer the only input. The same architecture now handles images, audio and documents. GPT Image 2.0 applies the reasoning idea to pictures, planning a composition before rendering it rather than generating directly.
• Tools instead of recall. Models that can search, run code or call other systems sidestep the pre-training cutoff for the things they actually fetch. This is the most significant change to the limitations described above, and it is why the same model can be unreliable in one product and dependable in another.
• Small models are catching up. The cheap fast tiers now handle a great deal that required the flagship two years ago. For most everyday work the expensive model is no longer the obvious choice, which is worth revisiting if you settled on one a while ago.

What has not changed is the mechanism. These are still systems predicting what comes next, which means the failure modes described earlier still apply however capable the newest release is.

Once you know that these models share an architecture but differ in training and tuning, the practical question stops being which one is best and becomes which one suits this task. That is difficult to answer from articles and easy to answer by trying: the same prompt through two models, on your own work, tells you more in a minute than any comparison will.

Chat Smith exists for that. The model list includes GPT tiers alongside Claude, Gemini, Grok and DeepSeek, so you can match a reasoning model to a hard problem, a fast tier to twenty drafts you will discard, and a long-context model to the document nobody wants to read - without a separate subscription for each. Chat Smith is free to try.

And the one thing worth carrying away from all of this: a GPT is a very good predictor of what text should come next, and that is both why it is remarkable and why it is unreliable about facts. Use it for transformation, explanation and options. Verify anything specific. That single distinction will get you more out of these tools than any prompt technique.