AI Jargon: What It Means

AI use has exploded. Every product update, every LinkedIn post, every conference keynote seems to come wrapped in a new piece of jargon — and half the time, even the people using the words aren’t entirely sure what they mean. AI companies have yet to prove how any of this makes real money for anyone who isn’t a shovel maker (looking at you, Nvidia), but the research into how these systems work has moved at a breakneck pace. That pace has left a trail of new terminology in its wake, and it’s easy to feel like you need a glossary just to follow a five-minute demo video.

So here’s that glossary — but instead of just listing terms alphabetically, this piece groups them the way they actually show up in a real AI system: from the silicon at the bottom, up through training, refinement, everyday use, and finally the safety layer wrapped around the whole thing. By the end, the jargon should stop feeling like buzzwords and start feeling like a pipeline you can actually picture.

The Bedrock: Hardware and Low-Level Math

Everything an AI model does eventually boils down to enormous amounts of arithmetic. That math is stored and processed as a Tensor — a multi-dimensional grid of numbers, essentially a spreadsheet with more than two dimensions. Regular computer chips (CPUs) are far too slow at this kind of repetitive number-crunching, which is why the industry leans on Neural Accelerators: specialized chips built specifically to run AI calculations fast.

Two accelerators show up constantly. TPUs (Tensor Processing Units) are Google’s custom chips, purpose-built to train and run AI models efficiently in the cloud. NPUs (Neural Processing Units) are their local cousins — smaller, more power-efficient chips increasingly built into modern phones and laptops so AI tasks can run without needing an internet connection. Alongside both sit GPUs (graphics chips repurposed for AI math), and when a system’s chips simply can’t keep up with the demand placed on them, engineers say the task has become GPU Bound — slowed down not by the rest of the computer, but specifically by the graphics hardware’s limits.

This layer rarely gets talked about outside engineering circles, but it’s the literal foundation everything else sits on. No tensor math, no AI.

Training the Base Brain: How a Model Gets Built

Artificial Intelligence (AI) is the broad umbrella: building computers or software that can perform tasks normally requiring human intelligence, like recognizing speech or making decisions. Machine Learning (ML) is the dominant approach to that goal — instead of programming every rule by hand, you let the computer find patterns in data on its own. Deep Learning (DL) is a specialized flavor of ML that uses multi-layered virtual “brains” to handle genuinely complex patterns, like picking one specific face out of a crowded photo.

Those “brains” are Neural Networks — structures loosely inspired by how neurons connect in a human brain, processing information layer by layer to arrive at a decision. Most modern neural networks use the Transformer architecture, a 2017 breakthrough that let models look at an entire sentence at once instead of word-by-word, which is a big part of why language AI improved so quickly. Transformers rely on an Attention Mechanism — a way of letting the model focus on whichever parts of the input actually matter for the task at hand, similar to how you zero in on key words to understand a sentence’s meaning.

To build any of this, an Algorithm (a step-by-step set of instructions, like a digital recipe) feeds the network huge amounts of Training Data — books, websites, images, audio, whatever’s relevant. As the network works through that data — whether it’s language (Natural Language Processing, or NLP) or images (Computer Vision) — it adjusts billions of internal “knobs and dials” called Parameters, which is really what “learning” means at a technical level. Depending on how that training is set up, it might be Supervised Learning (learning from labeled examples, like flashcards with the answer on the back), Unsupervised Learning (finding patterns with no answer key at all), or Reinforcement Learning (learning through trial and error, rewarded for good outputs like a dog trained with treats).

Training doesn’t always go smoothly. Overfitting happens when a model memorizes its training data too rigidly, like a student who crammed answers to a practice test and falls apart on the real exam. Underfitting is the opposite problem — the model hasn’t learned enough, so its answers stay too simple or vague. And if the training data itself carries social prejudices or skewed representation, the model can pick up Algorithmic Bias, producing outputs that unfairly favor or disadvantage certain groups.

Some architects also use a Mixture of Experts (MoE) design — instead of one enormous network handling every request, the model is built from many smaller specialized sub-networks, and only the relevant ones “wake up” for a given task, keeping things faster and cheaper to run.

If training goes well, the result is a Foundational Model — a large, general-purpose AI trained on broad data that can serve as the base for more specific tools — or, at the very top of the pack, a Frontier Model: the most advanced, cutting-edge systems available at a given moment. A Large Language Model (LLM) is simply a foundational model specialized in text — trained on vast amounts of writing so it can understand, summarize, translate, and generate human-like language. And whatever the end result is called, it’s ultimately just a Model: the trained program itself, the thing that actually takes an input and produces an output.

Refinement and Efficiency: What Happens After Training

A freshly trained foundational model is, at its core, just a very sophisticated prediction engine — it doesn’t yet know how to be a helpful, safe assistant. That takes another round of work. Fine-Tuning takes an existing model and trains it further on a specific topic — legal documents, medical records, customer support transcripts — turning a generalist into a specialist. RLHF (Reinforcement Learning from Human Feedback) adds a human layer on top: real people score the model’s answers, teaching it to be safer, more helpful, and more natural to talk to.

Once a model works well, the next problem is cost — big models are expensive to run. Distillation solves part of that by training a smaller, faster model to mimic a larger one, keeping most of its ability while shedding most of its size. Quantisation takes a different route: it simplifies the model’s internal numbers, shrinking the file and speeding it up, at the cost of a small dip in accuracy. Both tricks are part of why AI can increasingly run On-device — directly on your phone or laptop, rather than needing a round trip to a remote server.

Finally, the creators have to decide how to release what they’ve built: locked behind a paid API, or shared publicly as Open Weights, letting anyone download and run the model’s trained settings for themselves.

Running the Model: What Happens When You Hit “Enter”

Everything above happens once, ahead of time. What happens when you actually use the model is called Inference — the live moment where a trained model takes your input and generates a response. You start that process with a Prompt: the text, question, or instruction you type in. Prompt Engineering is the skill of phrasing that instruction carefully to coax out better, more accurate answers — and some systems use a related trick called pre-fill, where the first few words of the model’s own answer are written for it in advance, nudging its tone or starting point before it continues on its own.

Before any of this can be processed mathematically, your prompt gets chopped into Tokens — bite-sized chunks of text, sometimes whole words, sometimes just fragments of one. All of this has to fit inside the model’s Context Window, its “short-term memory” — the total amount of text it can read and consider at once before earlier parts start dropping out of view. Impressively, a well-trained model can often handle Zero-Shot Learning — successfully doing a task it’s never explicitly been shown an example of before, just by generalizing from what it already knows.

None of this is free. Running inference — the electricity, the chip time, the cloud infrastructure — carries a real Inference Cost, separate from (and ongoing, unlike) the one-time cost of training.

Action, Integration and Safety: The Top Layer

At the surface, where most people actually experience AI, things get more ambitious. Generative AI (GenAI) describes systems built specifically to create original content — essays, music, artwork, code — rather than just analyze it. Multimodal AI takes that further, understanding and blending different formats at once: text, images, video, and audio processed together rather than separately.

One of the most talked-about weaknesses at this layer is the Hallucination — when an AI confidently presents completely false or fabricated information as if it were fact. One common fix is RAG (Retrieval-Augmented Generation), where the model checks an external, reliable database before answering, essentially consulting an open textbook instead of relying purely on memory.

When a system is given a high-level goal and left to figure out the steps itself — using tools, making decisions, chaining actions together — it becomes an AI Agent, and this style of operating is what people mean by Agentic AI. Because agents can take real actions, they’re often run inside a Sandbox: an isolated, safe space to test what they do without risking real systems or data.

Wrapped around all of it are Guardrails, also called Alignment — the safety rules and boundaries designed to keep a system honest, safe, and helpful, and to stop it from producing toxic or illegal content. Watermarking adds one more layer of accountability, embedding a hidden signal in AI-generated content so it can later be identified as AI-made rather than human-made.

And looming over all of it, still theoretical, is AGI (Artificial General Intelligence) — the hypothetical future milestone where a single AI system matches or exceeds human-level intelligence across virtually any cognitive task, rather than being good at one narrow thing at a time.

Conclusion

Strip away the marketing language and the jargon stops being intimidating — it’s really just a pipeline: chips do the math, training builds the base model, refinement makes it cheaper and safer, inference is you actually using it, and a safety layer sits on top trying to keep the whole thing honest. If you can translate the jargon, things get a lot clearer. Hopefully this explainer does exactly that — clarifying the concepts enough to see past the hype surrounding AI models and the systems built on top of them.

Love this? Consider buying me a coffee!