AI glossary

AGI (artificial general intelligence) is a concept at the intersection of science and futurology: a system that could handle any intellectual task as well as a human, not just a narrow specialization. Current models, though impressive, remain specialized and have no independent goals or human-level understanding of the world.

Researchers disagree on when or whether AGI will emerge - predictions differ by decades. The AGI discussion is tied to questions about safety and control over such powerful technology.

Artificial intelligence is a broad field of computer science in which computers perform activities that usually require human thinking: they recognize speech, translate languages, hold conversations, or create images. Today's AI systems are mainly based on machine learning, meaning they learn from data instead of working according to rigidly coded rules.

How it works: a model analyzes huge sets of examples and detects patterns in them, which it then applies to new situations.

Example: an assistant that summarizes a long document in English or generates graphics from a short description is a practical application of AI.

An API (application programming interface) is a set of rules that lets one program use another. In the AI context, it's the channel through which your application sends a prompt to the model and receives a response, without needing to maintain your own model on your hardware.

How it works: you send a request with text and parameters (e.g., temperature), and the service returns generated content, typically billed by the number of tokens.

Example: a mobile app that asks the model via API to summarize an article.

An AI agent is a system that adds an action loop around a language model: it breaks down a goal into steps, selects tools, executes them, and evaluates the result until the task is complete. Instead of a single response, you get a sequence of actions leading to the goal.

How it works: the model receives descriptions of available tools (function calling), then in successive turns decides which to invoke and with what data.

Example: an agent that independently searches the internet, gathers data, and saves a finished report to a file.

Alignment is the research area and practices aimed at making a model do what we actually want, rather than just literally executing instructions in harmful ways. It covers safety, honesty, and predictable behavior.

Tools: include RLHF, guardrails, and careful testing before deployment.

A benchmark is a standardized set of tasks with established scoring that allows comparing different models under the same conditions. This enables relatively objective assessment of which model performs better on, say, mathematical tasks, coding, or general knowledge questions.

Benchmark results must be read carefully: a model may be inadvertently trained on data similar to the test, inflating results. That's why real-world performance on practical tasks is equally important.

Bias is the model's tendency to favor certain responses or groups, stemming from imbalances and prejudices present in the data it was trained on. It can lead to unfair or harmful outcomes.

How to mitigate: careful data selection, testing across different groups, and response control mechanisms. Complete elimination of bias is difficult.

Chain-of-thought is a way of asking the model to break down its reasoning into sequential steps before giving the final answer. Breaking a problem into stages clearly improves accuracy on logical, mathematical, and multi-step tasks.

How it works: in your prompt you ask for a step-by-step solution, or the model itself generates intermediate steps before formulating the final answer.

Example: for a math word problem, the model first writes out the operations, then gives the result at the end.

A chatbot is a program that simulates conversation with a user. In the past they relied on rigid rules and keywords; today's chatbots use large language models, allowing them to understand natural questions and respond in fluent language.

Example: an assistant on a store website answering shipping questions, or ChatGPT as a universal conversational partner for writing and analysis.

Context caching is a mechanism where a once-computed fragment of a prompt (e.g., a long instruction or document) is remembered so it doesn't need to be recomputed in subsequent queries. This reduces cost and latency in repeated conversations.

Example: an assistant with an extensive system prompt can cache its processed version between queries.

A dataset is an organized collection of data - texts, images, recordings - used to train or evaluate a model. The rule "garbage in, garbage out" applies: faulty or biased data corrupts the model.

Best practice: data is split into training, validation, and test sets to fairly assess model performance.

A deepfake is a manipulated or entirely generated recording in which someone supposedly says or does something they never did. The technique relies on models that learn faces and voices from samples, then reproduce them in a new context.

Why it matters: deepfakes can be tools for disinformation and fraud (e.g., impersonating a boss's voice). It's worth verifying sources and looking for inconsistencies in lighting or facial expressions.

Diffusion models generate images by starting with pure noise and gradually "denoising" it toward a coherent scene described by the prompt. During training, the model learns to reverse the process of adding noise to real images.

How it works: in dozens of steps, the model increasingly accurately predicts what the image should look like, until the final graphic emerges.

Example: you enter a scene description, and Stable Diffusion or Midjourney returns a finished image.

Distillation (knowledge distillation) is a technique where a large, powerful model (teacher) trains a smaller model (student) to mimic its responses. The result is a lighter model, cheaper and faster to run, while retaining much of the original's quality.

Use case: mobile versions of models and budget deployments are often created through distillation.

An embedding is a representation of text (or image) as a vector of numbers, where semantically similar concepts have similar values. This lets computers measure content similarity even when different words are used.

How it works: the model converts a text fragment into hundreds or thousands of numbers; by comparing vectors, the system finds the most relevant passages.

Example: a semantic search engine that for the question "how to lower electricity bills" finds a paragraph about saving energy, even though it doesn't contain those exact words.

Few-shot is a technique where you include several example question-answer pairs in the prompt itself before asking your actual question. The model picks up the desired format and style from them, without needing fine-tuning.

Example: you show two examples of how to convert a review into a "positive/negative" rating, and the model applies the same pattern to subsequent reviews.

Fine-tuning is continued training of an already-trained model on a narrower, specialized dataset. The model retains general knowledge but better adapts to a specific style, domain, or response format.

When to use it: when prompts alone aren't enough and you have plenty of examples showing the desired behavior. For many use cases, RAG or good prompting is a cheaper alternative.

A foundation model is a model pre-trained on massive, general data that then serves as the foundation for specific applications - through prompting, RAG, or fine-tuning. Instead of training from scratch, you build specialized solutions on top of it.

Example: one foundation model can power a chatbot, company search engine, and code assistant.

Function calling allows the model not only to write text but also to decide that a specific tool needs to be used, and return structured input data to execute it. Your program runs the function and passes the result back to the model.

How it works: you give the model descriptions of available functions; the model responds with a structure (e.g., function name and arguments) that your code can safely execute.

Example: when asked about weather, the model calls a forecast-checking function instead of guessing.

GPUs (graphics processors) and TPUs (Google's AI chips) are hardware optimized for the massive parallel computations required by training and running neural networks. Thanks to them, models compute much faster than on a regular processor (CPU).

Why it matters: GPU availability and cost are now one of the main factors limiting AI development and deployment.

Generative AI refers to models whose task is to create new content based on patterns learned from data. Unlike classification, which only assigns labels, generation produces original text, images, sound, or video.

Example: writing a poem, generating an illustration from a description, or composing a melody are typical generative tasks.

Guardrails are a set of rules and filters ensuring the model doesn't generate harmful, illegal, or dangerous content. They can work on input (blocking bad requests) and output (controlling responses).

Why they matter: they protect users and the company deploying the model from abuse, though they're often targets of bypass attempts (jailbreak, prompt injection).

A hallucination is a response that sounds plausible but is false: the model invents a fact, quote, citation, or name. This happens because the model predicts a probable sequence of words rather than checking truth against a database.

How to reduce them: ask for sources, use RAG (connecting to a reliable knowledge base), and always verify numbers, dates, and quotes before publishing.

Inference is the phase of using a ready model: you provide a prompt and the model computes a response. This differs from training, the expensive process of teaching the model on data, which happens earlier and only once.

Why it matters: inference cost and speed determine service pricing and the latency users experience.

Jailbreak is deliberately manipulating a prompt to trick the model into breaking its own rules, e.g., by casting it in a role without restrictions or hiding a request in an innocent scenario. It's one of the main security problems with models.

The difference: jailbreak targets the model's rules themselves, while prompt injection disguises external instructions as data the model processes.

An LLM (large language model) is a neural network trained on gigantic text datasets that has learned to predict the next words. This enables it to write, translate, summarize, code, and hold conversations.

How it works: the model converts text into tokens and predicts the most likely next token based on context, repeating this until a complete response is formed.

Example: ChatGPT, Claude, and Gemini are interfaces to large language models.

Latency is the delay: how long you wait before the model starts and finishes responding. It depends on model size, response length, server load, and network distance.

Why it matters: in live applications (chat, voice), low latency determines comfort; it's often improved by streaming the response token by token.

Machine learning is a subfield of AI where instead of writing rigid rules, you show a program many examples and it extracts patterns from them. The better and more numerous the data, the more accurate the predictions.

Example: a spam filter learns from thousands of labeled emails what spam is, and applies that knowledge to new messages.

MoE (mixture of experts) is a model architecture with many specialized sub-networks ("experts"), of which only a few activate for any given token. This allows a model to have very many parameters while computing answers relatively cheaply.

How it works: a gating mechanism decides which experts handle a given fragment, so only part of the entire network is active.

A multimodal model understands and combines different types of data in one place: it can, for example, look at a photo and describe it in words, or listen to a recording and summarize it. This is a step closer to how humans perceive the world through multiple senses.

Example: you upload a photo of a whiteboard with notes, and the model transcribes and organizes the content, answering questions about it.

NLP (natural language processing) is a branch of AI dealing with understanding and generating human language: translation, sentiment analysis, information retrieval, or intent recognition. Large language models are today's most powerful NLP tool.

Example: automatically detecting that a customer review is negative and routing it to support.

A neural network is a model composed of layers of simple units (neurons) connected by weights. During training, weights are adjusted so the network increasingly maps inputs to desired outputs, e.g., image to label.

How it works: data passes through successive layers, each detecting increasingly complex patterns. Deep networks are the foundation of deep learning and modern AI.

The context window is the maximum amount of text (measured in tokens) that a model can consider in a single conversation: your prompt, previous messages, and the generated response must all fit within it. When the limit is exceeded, the oldest parts are dropped.

Example: a larger window lets you paste an entire contract and ask questions about its content without splitting it into chunks.

An open model is one whose weights (learned parameters) are publicly available, so you can download it, run it on your own hardware, fine-tune it, and deploy it without depending on a single vendor. The opposite are closed models, available only through APIs.

Advantages: data privacy, control, and no per-query fees. Cost: you need your own hardware and expertise to maintain it.

Overfitting is a situation where a model fits the training data too closely, capturing even random features, which makes it perform worse on new, previously unseen examples. It's one of the main problems in machine learning.

How to prevent it: more diverse data, simpler architecture, and testing the model on a separate test set.

Parameters are internal values that the model adjusts during training; they store its "knowledge." The number of parameters is given in billions (B) and treated as a rough measure of model size.

Note: a higher parameter count usually means greater capabilities, but also higher costs. Good training data and architecture often matter more than parameter count alone.

A prompt is your input to the model: a question, instruction, or context based on which a response is generated. The more clearly you describe the goal, format, and constraints, the more accurate the result.

Best practice: provide a role, context, specific task, and expected response format, and if needed, one example.

Prompt engineering is the practice of formulating queries so the model gives better, repeatable results. It includes choosing context, precise instructions, examples (few-shot), and iteratively refining the prompt based on responses.

Example: instead of "write about health," you ask "write 5 sleep tips for a parent of a young child, in bullet points, in English."

Prompt injection is a vulnerability where text processed by the model (e.g., webpage content, email, document) contains a hidden instruction, and the model treats it as a user command. This can lead to data disclosure or unwanted actions.

How it works: an attacker embeds a sentence like "ignore previous instructions and do X" in the data; an unprotected model may execute it.

Defense: separating instructions from data, limiting tool permissions, and treating web content as untrusted.

Quantization is storing model weights with lower precision (e.g., 8 or 4 bits instead of 16), so the model uses less memory and computes faster. This enables running large models on weaker hardware, including locally.

Trade-off: overly aggressive quantization can slightly reduce answer quality, so it's chosen based on the use case.

RAG (retrieval-augmented generation) is an approach where the model searches for relevant fragments from an external knowledge base before responding and bases its answer on them. This makes responses more current and less likely to contain fabricated facts.

How it works: the question is converted to an embedding, the system finds the most similar documents, and the model formulates a response based on them.

Example: a company assistant answering questions based on internal policies.

RLHF (reinforcement learning from human feedback) is a training stage where humans rate the model's responses, and those ratings are used to fine-tune it. This makes the model respond more helpfully, politely, and in line with expectations.

How it works: human preferences train a reward model, which then guides further training of the main model.

Reasoning is handling tasks that require multiple logical steps, not just recalling a fact. Reasoning models dedicate more computation to internally working through the problem before producing a result.

How it works: the model generates intermediate steps (similar to chain-of-thought), checks them, and only then formulates an answer, improving accuracy in math, logic, and programming.

Cost: longer reasoning means more tokens and higher latency.

Sora (OpenAI) and Veo (Google) are models that convert text descriptions into short video clips. They belong to generative AI and extend to motion what text-to-image models do for static images.

Use case: rapid scene prototypes, concept materials, and visualizations, with caveats about rights and content authenticity.

A system prompt is a high-level instruction set by the application creator that gives the model a role, tone, and boundaries for the entire conversation. Users typically don't see it, but it influences every response.

Example: "You are a courteous tax advisor, you respond in English and do not provide legal advice" is a typical system prompt.

TTS (text-to-speech) converts written text into natural-sounding speech, while STT (speech-to-text) does the reverse-transcribing audio into text. They're the foundation of voice assistants, narrators, and automatic transcription.

Example: STT creates captions for a meeting recording, while TTS reads an article aloud in an app.

Temperature is a parameter controlling response randomness. At low values the model chooses the most probable words, so it's consistent and repeatable; at high values it more often reaches for less obvious options, yielding more creative but less predictable results.

When to use which: for facts and code set low temperature, for brainstorming or creative writing set higher.

Text-to-image is the conversion of a text description into an image. The model, usually diffusion-based, translates words into visual features of a scene: objects, style, colors, and composition.

Best practice: the more specific the description (subject, style, framing, lighting), the more accurate the image. It's worth iterating and refining the prompt.

A token is the smallest unit of text that a model processes-usually a short word or its fragment. The model doesn't see letters or sentences directly, but a sequence of tokens, and tokens are used to measure prompt length, context window, and cost.

Roughly: for English, one token is often a few characters, and one word may be split into several tokens.

Tokenization is the first step in text processing: converting a string of characters into a list of tokens according to the model's vocabulary. It determines how many tokens a given text takes, and thus cost and context window usage.

Fun fact: languages with rich inflection can be split into more tokens than English, raising the cost of the same content.

The Transformer is a neural network architecture that uses an attention mechanism to connect distant parts of text and process sequences in parallel. It enabled the breakthrough in quality for language models.

Why it matters: the attention mechanism lets the model "look at" the entire context at once, improving understanding of dependencies in long text.

Vibe coding is a workflow where you describe to the model what you want to build, it generates and refines the code, and you mainly guide and test the result. It speeds up prototyping and lowers the barrier to programming.

Note: for larger projects, human verification of security and code quality is still essential.

A watermark in AI content is a hidden pattern embedded in text, images, or audio that allows later detection that the material was machine-generated. It's meant to help combat misinformation and label synthetic content.

Limitation: watermarks can be removed or aren't always detectable, so they don't provide complete certainty about origin on their own.

Zero-shot is when a model performs a task based solely on the instruction, without being shown any examples. Large models often handle this surprisingly well thanks to knowledge gained during training.

When to add examples: if the format or style is unusual, it's worth switching to few-shot and showing a pattern.