AI & Automation Glossary

Artificial Intelligence is the field of building computer systems that perform tasks which once required human intelligence — understanding language, recognizing images, making decisions and solving problems. Most 2026 AI is built on machine learning: the system learns patterns from vast amounts of examples rather than being hard-coded with rules.

Machine learning (ML) is the core approach in AI: instead of writing rules by hand, you feed an algorithm examples and it learns a function that maps input to output. The more high-quality data it sees, the better the model generalizes to new cases it never encountered during training.

Deep learning is a branch of ML that uses neural networks with many layers. Each layer learns a more abstract representation of the data — from pixels to edges, edges to shapes, and shapes to objects. It's the technology behind almost every modern AI breakthrough, including language models.

A neural network is a brain-inspired mathematical model: compute units ("neurons") are connected in layers, and each connection carries a weight that is updated during training. The network takes numbers as input, passes them through the layers, and produces a prediction as output. Its depth and size determine how complex the patterns it can learn are.

A Large Language Model is a huge neural network trained on massive amounts of text to predict the next word (token). From this seemingly simple ability emerge capabilities in conversation, writing, code and analysis. Leading families in 2026: GPT-5.6, Claude Opus 4.8 and Gemini 3 Pro.

The Transformer is the architecture that powers almost every modern language model. Its strength is the attention mechanism, which lets the model weigh which parts of the text are relevant to each other — even when they're far apart in a sentence. This breakthrough (2017, "Attention Is All You Need") made efficient training at enormous scale possible.

A token is the basic unit of text a language model processes — roughly a word, part of a word, or a symbol. The model "sees" and bills by tokens, not words. Understanding tokens matters both for cost (you pay per token) and for the context window.

Parameters are the model's internal "weights" — the numbers learned during training that encode its knowledge. A model with more parameters can capture more complex patterns but is also more expensive to run. The parameter count (e.g. billions) is a rough measure of a model's size and capability.

Training is the expensive, one-time process where the model learns from data and tunes its parameters. Inference is everyday use — running the trained model to get an answer. Most of an end user's cost is in inference, so model choice and smart routing directly affect the budget.

Fine-tuning is continued training of an existing model on your own focused data, to specialize it for a task, style or domain. It's useful when you need a consistent format or niche knowledge that's hard to achieve in a prompt. For most cases RAG or a good prompt is cheaper and faster — fine-tuning is reserved for tasks with specific, recurring requirements.

A prompt is the input you give a model — the question, instruction or context. Output quality depends almost entirely on prompt quality: clear context, a role definition, examples and a desired output format improve results dramatically. A good prompt is the cheapest and most powerful lever for better performance.

Prompt engineering is the discipline of crafting inputs to reliably and repeatably get the most out of a model. It includes techniques like role setting, few-shot, chain-of-thought and requesting a structured format. It's a practical skill that improves accuracy, consistency and safety — without touching the model itself.

The system prompt is a top-level instruction that defines the model's role, tone and rules for the entire conversation — before the user types a word. It's where you set boundaries ("don't invent facts"), a fixed format and an identity. When building a product, a strong system prompt is the difference between a reliable agent and one that drifts off task.

The context window is how much text (in tokens) a model can "hold in mind" at once — the prompt, the history and any attached documents. A large window lets you analyze long documents and hold long conversations, but filling it raises cost and latency. Managing the context wisely (what to include vs. summarize) is a key skill.

Temperature is a parameter controlling how "random" the output is. A low value (near 0) gives focused, consistent, predictable answers — good for code, data extraction and classification. A high value is more varied and creative — good for ideation and writing. Choosing the right temperature for the task greatly improves the result.

Zero-shot is asking the model to do a task with no examples; few-shot is including a few examples of the desired input→output inside the prompt. Good examples teach the model the exact format, tone and standard you expect — and usually improve accuracy significantly without any training.

Chain-of-Thought (CoT) is a technique where you ask the model to "think step by step" and show its reasoning before the final answer. Breaking a problem into steps significantly improves accuracy in math, logic and code. Advanced 2026 models do this internally, but an explicit request still helps on complex tasks.

A hallucination is when a model produces information that sounds authoritative but simply isn't true — a fabricated fact, a nonexistent source or a wrong citation. It stems from the model predicting plausible text, not verified truth. The main ways to reduce it: RAG (grounding in sources), asking for citations, and verifying critical output against a reliable source.

A multimodal model understands and generates more than one type of media — text, images, audio and video. You can show it a screenshot and ask a question, transcribe a conversation, or analyze a diagram. This capability became standard in 2026 and greatly expands the kinds of tasks you can automate.

Structured output is forcing the model to return an answer in a fixed, precise format — usually JSON matching a defined schema. It's critical when the output feeds another system (an API, a database, a workflow) and you can't rely on free text. Modern models support a JSON mode or function calling that guarantees valid output.

RAG is the pattern where, before the model answers, relevant snippets of information are retrieved from your store (documents, a knowledge base) and added to the prompt. This way the model answers based on your sources, not just its general knowledge — which reduces hallucinations and enables up-to-date, verifiable answers. It's the most common architecture for an enterprise knowledge chatbot.

An embedding is a representation of text (or an image) as a vector of numbers that encodes its meaning. Texts with similar meaning get vectors that are close together in space. It's the technology that enables semantic search and RAG: instead of matching exact words, you compare closeness of meaning.

A vector database stores embeddings and lets you quickly search for the vectors closest to a query — i.e. the most relevant snippets by meaning. It's the component that stores the knowledge in RAG. Common examples: Pinecone, Weaviate, Qdrant and pgvector.

Semantic search finds results by meaning rather than keyword matching. A query like "how do I cancel a subscription" will find a document that says "closing your account", even with no shared words. It's built on embeddings and is the heart of retrieval in RAG and modern search engines.

Chunking is splitting long documents into small pieces before embedding them for RAG. Chunk size matters: too large brings in irrelevant "noise", too small loses context. Good splitting (e.g. by paragraphs with slight overlap) dramatically improves retrieval and answer quality.

Reranking is a second retrieval step: after pulling many candidates (fast but rough), a dedicated model ranks them by true relevance to the question and picks the best ones. It significantly improves RAG quality — fewer irrelevant snippets reach the model, so fewer hallucinations and more accurate answers.

An AI agent is a system where a language model doesn't just answer but acts: it plans, uses tools (search, code, APIs), checks results and corrects itself — until a goal is complete. Unlike a one-off chat, an agent runs in a think-act-observe loop. It's the central pattern behind smart automation in 2026.

"Agentic" describes systems that act autonomously across several steps to achieve a goal, rather than responding to a single request. An agentic approach involves planning, tool use, memory and reflection. The more complex and multi-step the task, the more an agentic approach (versus a single prompt) pays off.

MCP is an open standard (from Anthropic) for connecting models to external tools and data sources in a uniform way. Instead of writing a custom integration for every tool, you build one "MCP server" that any supporting agent can connect to — like "USB-C for AI". It became a key foundation for connecting agents to real systems in 2026.

Tool use (or function calling) is a model's ability to call external functions — search the web, run code, send an email or hit an API. The model decides when and how to use a tool, and folds the result into its answer. This is what turns a model from a conversationalist into an agent that performs real-world actions.

ReAct is an agent pattern where the model alternates between Reasoning (analyzing the situation and planning the next step) and Acting (invoking a tool), feeding the observations back into its reasoning. This loop lets an agent handle multi-step tasks and correct itself as it goes.

A multi-agent system splits a task among several specialized agents — e.g. a "researcher", a "writer" and a "critic" — that coordinate. The division enables specialization, mutual checking and solving complex problems a single agent would struggle with. The downside: more complexity, cost and latency — so it's worth it only when the task truly demands it.

Agent memory is the ability to retain information beyond a single context window — user preferences, learned facts and task history. Short-term memory manages the current conversation; long-term memory (usually stored in a vector database) lets an agent recall and improve over time. It's critical for personal assistants and ongoing support.

A2A is a standard for communication between agents — letting agents from different systems discover each other, hand off tasks and collaborate. If MCP connects an agent to tools, A2A connects an agent to other agents. Together they form the foundation for an ecosystem of cooperating agents.

Computer Use is a model's ability to operate a computer like a person — see the screen, move the mouse, click and type. This lets an agent perform tasks in apps and websites that have no API. It's a powerful but sensitive capability that requires boundaries and oversight because of the risk of unexpected actions.

Automation is performing repetitive tasks with no manual intervention — from moving data between apps to entire workflows. Combined with AI, automation becomes "smart": it doesn't just move information but understands, summarizes and decides. Platforms like n8n, Make and Zapier let you build automations without writing much code.

A workflow is a defined sequence of automated steps: a trigger that starts the process, then a chain of actions and conditions leading to a result. For example: "new email arrives → summarize with AI → save to a Sheet → send to Slack". Building workflows is the practical way to turn a manual process into an automated one.

A webhook is a URL that listens for events: when something happens in one system (a form is submitted, a payment is made), it automatically "pushes" a message to that URL and triggers a process. It's the most common glue between systems in automation — the way one app notifies another in real time.

An API is the "menu" through which one piece of software talks to another — it defines what requests you can send and what responses you'll get. Almost every service (OpenAI, Google, a CRM) exposes an API. Basic API literacy lets you connect tools, build automations and embed AI into existing products.

No-code is building software and automations through a visual interface, without writing code; low-code adds the option of custom code where needed. This approach makes building apps and automations accessible to non-programmers and greatly speeds up development — tools like n8n, Make and Bubble are leading examples.

LLMOps is the set of practices for running language models reliably in production — managing prompts and versions, monitoring cost and latency, measuring quality (evals), handling errors and versioning models. It's what separates an impressive demo from an AI product that runs stably over time and at scale.

Evals are systematic tests that measure how well a model or agent performs a task — over a set of examples with desired answers. Instead of "looks good", you get a measurable score that lets you compare models, catch regressions after a prompt change, and decide with confidence. Evals are the foundation of reliably improving AI systems.

Guardrails are control mechanisms that limit what a model can take as input or produce as output — filtering harmful content, preventing exposure of sensitive data, enforcing a format and validating correctness. They're the protective layer that turns an agent from "impressive" into "safe for production use", especially with end users.

Prompt injection is an attack where an attacker embeds malicious instructions inside content the model reads (an email, a website, a document), to make it ignore its original instructions — for example to leak information or perform an unauthorized action. It's one of the central security problems for agents, and requires separating trusted instructions from external content.

Observability in AI systems is the ability to see what's happening inside — which prompts were sent, which tools were invoked, how much it cost, and how long it took. Without observability, an AI system is a "black box" you can't debug. Monitoring tools let you find failures, cut costs and improve quality systematically.

Context engineering is the discipline of managing what goes into the model's context window at each moment — the right prompt, the relevant information and the necessary history, without flooding it with noise. Four key strategies: write (store externally), select (retrieve), compress (summarize) and isolate (separate). It's the foundation for agents that are reliable and cost-efficient.