Glossary

What you meet before any AI at all: how typed words become computer actions.

• TerminalA window you type into to talk to your computer.example
• CLI (Command-Line Interface)Directing a computer by typing instead of clicking.example
• ShellThe program that reads what you typed and goes and runs it.example
• PATH and file pathsA path is a file's address. PATH is the list of folders the computer searches when you name a program.example
• Environment variables and .envConfiguration a program reads from outside itself, instead of values hardcoded in the source.example
• GUI (Graphical User Interface)The point-and-click face of a program: windows, buttons, menus and icons — the counterpart of the type-it-yourself command line.example
• Working directoryThe folder you are currently "standing in": any command that does not name a full path acts here by default.example
• Config fileA file a program reads its own settings from — which model, which port, where keys live — written once, applied on every run.example
• JSON (JavaScript Object Notation)A lightweight data format in plain text that both humans and programs can read — the common language of AI tooling.example
• YAMLThe other common config format: nesting expressed by indentation, closer to a human outline than JSON — and far pickier about whitespace.example
• ProcessA program while it runs: it owns its memory, has its own number (PID), and lives until it exits or is killed.example
• PortA number appended to an address so one machine can run many network services at once without mixing them up.example
• Localhost"This very machine": localhost is the name, 127.0.0.1 the address. A service bound to it can be reached only from this computer.example
• Standard streams (stdio)The three data pipes every process is born with: stdin to read from, stdout for normal output, stderr for errors — three separate channels.example
• Exit codeThe integer a program hands back as it exits: 0 means success, anything else means failure — how a program reports its outcome to the world.example
• File permissionsRules attached to every file saying who may read it, change it and execute it — the first gate the system checks when you touch a file.example
• sudo (superuser do)Run this one command as the administrator (root): the command stays the same, the identity changes.example
• HomebrewThe de-facto package manager on macOS (and Linux): one command to install, update and remove tools and applications.example
• IDE (Integrated Development Environment)A program that bundles code-writing with everything around it in one window: a file tree, syntax highlighting, an integrated terminal, run and debug.example
• DotfileFiles whose names begin with a dot: hidden from listings by default, because they are usually configuration rather than content you browse.example

Names you keep hitting while installing tools and running examples. You do not need to write code, but you do need to recognise these.

• PythonA programming language, and also the program that runs it. Almost every AI tool's docs, examples and error messages are written in it.example
• Node.jsThe program that lets JavaScript run outside a browser — and the thing many AI command-line tools are installed and launched with.example
• Package managerA tool that downloads, installs, updates and removes other people's software for you. Each ecosystem has its own.example
• pipPython's own installer: it fetches packages from the PyPI repository and puts them into whichever Python you are currently using.example
• Virtual environment (venv)A project-private folder of Python packages, kept apart from the system. Once activated, whatever pip installs lands only inside it.exampledeep dive
• DependencyFor your program to work, other people's programs must already be present. Those prerequisites are its dependencies.example
• Repository (repo)A project folder plus a record of every change made to it since day one.example
• Git (version control)A tool that records how a folder changes over time: who changed what, when — and lets you go back at any point.example
• CommitOne save: the project's entire state at one moment, recorded together with a note explaining it.example
• BranchA parallel line of work forked off the main one. However much you change on it, the main line does not move.example
• Clone and forkclone copies a remote repo onto your computer with a command; fork copies someone else's repo into your own account on a website.example
• Pull request (PR)A formal request saying 'I have made these changes — please decide whether to take them in'. It is a human review process, not a command.example
• ScriptA file holding a sequence of commands run in order — the things you would otherwise type in a terminal, saved so they can be run again.example
• FunctionA named, reusable piece of code: you give it inputs and it hands back an output.exampledeep dive
• Library vs frameworkA library is something you call; a framework is something that calls you.exampledeep dive
• API (Application Programming Interface)A published contract: send a request in the specified shape and get a reply in the specified shape, with no need to know how the other side works internally.example
• SDK (Software Development Kit)A service's own pre-packaged toolkit: it wraps the details of calling its API into a few convenient functions so you do not assemble requests yourself.example
• Regex (regular expression)A notation for describing what a piece of text looks like, used to find or validate matching fragments inside larger text.example
• DebuggingReading an error message properly, finding the line that actually failed, and changing only that.exampledeep dive
• RuntimeTwo meanings: the program that executes your code (the Python interpreter, Node.js, a browser); and the period while your code is actually running, as opposed to the moment it was written.example

What happens when you call an API or reach another machine.

• API keyA secret string that tells a remote service "this request is yours, and the bill is yours".example
• SSH (Secure Shell)An encrypted connection into another computer's command line.example
• HTTPThe request/response language between clients and servers — and the transport every model API uses.example
• Request/responseOne round trip: you send a request, the server sends a response, and the connection can close — it does not remember your previous call.example
• Status codeThe three-digit number on the first line of a response, telling you whether the call succeeded, whether you made a mistake, or whether the server did.example
• Header (HTTP header)Notes attached to a request or response about this transfer: identity, content format, caching, where to redirect. The actual data is in the body; headers are the annotations on the envelope.example
• Rate limitThe cap on how many requests or tokens a service lets you send in a given window; go over it and you are throttled with a 429.example
• WebSocketA connection that stays open once established, letting both sides push data at any time — unlike HTTP's ask-once, answer-once, then close.example
• ProxyA middleman between you and the destination: your request goes to it first, it asks on your behalf, then relays the answer back.example
• CORS (Cross-Origin Resource Sharing)A browser security gate: when page JavaScript asks a server of a different origin for data, the server must explicitly allow it, or the browser blocks the response.example
• Private keyThe half of a key pair that must never leave you: it stays on your machine to prove "I am who I claim", while the matching public key can be shared openly.example

The model itself: what it eats, what it returns, and why it gets things wrong.

• LLM (Large Language Model)A neural network trained to predict the next token. It can only output text.animatedexampledeep dive
• TokenThe smallest unit of text a model handles. Not a character, and not a word.example
• Context windowThe total tokens a model can see at once — and input and output share that budget.example
• HallucinationThe model produces text that reads perfectly plausibly but is factually wrong or invented.example
• TokenizationThe rule set that chops text into tokens — and every model family chops differently.example
• TransformerA neural-network architecture built around attention, introduced in 2017; virtually every modern LLM is built on it.animatedexampledeep dive
• PromptThe entire token sequence sent to the model this turn: system instructions, conversation history, tool definitions, retrieved material, plus the sentence you actually typed — all of it.example
• System promptA standing instruction written by the developer — not the user — placed at the front of the prompt to frame the model's role, tone and boundaries.example
• TemperatureThe knob for sampling randomness: lower values push the model toward the highest-probability token; higher values give unlikely candidates a real chance.example
• Top-p (nucleus sampling)The other randomness knob: rank candidate tokens by probability, keep the smallest set whose cumulative probability reaches p (say 0.9), discard the tail entirely, then sample from what remains.example
• InferenceRunning an already-trained model to produce output — the counterpart of training, and the entirety of the computation that happens when you use a model.animatedexample
• Prefill and decodeThe two phases of a generation: prefill digests the entire prompt in one parallel pass (compute-bound, sets time-to-first-token); decode then emits one token at a time (memory-bandwidth-bound, sets tokens per second).example
• Fine-tuningTaking an existing model and continuing training on your own data, writing new behaviour or style into the weights.example
• QuantizationStoring model weights in lower-precision numbers, trading tolerable quality loss for dramatically smaller size and memory footprint.example
• Model file formatHow model weights are packaged on disk: GGUF, safetensors, MLX and friends are different boxes, and each runtime only opens the ones it supports.exampledeep dive
• MultimodalA model that handles more than text (images, audio, video): non-text input is converted into representations the model can read, sharing one context with the text.example
• Reasoning modelA model that generates a long internal chain of thought before answering, trading extra output tokens for higher accuracy on multi-step problems.exampledeep dive
• Frontier modelThe small set of most capable models at a given moment — a moving label, not a fixed technical specification.example
• MoE (Mixture of Experts)An architecture that keeps many "expert" sub-networks inside but routes each token to only a few of them — huge total parameters, much smaller compute per token.example

The layer of ordinary code that lets a model actually do things.

• AI agentAn LLM plus context, tools and a loop: the model decides the next step and can actually carry it out.exampledeep dive
• Tool callThe model does not act; it requests action by returning structured text saying "call this tool with these arguments".exampledeep dive
• HarnessThe layer of code wrapped around a model: assembling context, calling the model, parsing output, running tools, gating permissions, feeding results back.animatedexampledeep dive
• Agent loopThe agent's heartbeat: assemble context, call the model, parse its output, execute the action, feed the result back — repeat until the task is done or a stop condition fires.animatedexampledeep dive
• ReAct (Reason + Act)The model narrates a thought before each action, proposes the action, receives an observation, and repeats — reasoning and acting interleaved instead of separated.example
• PlanningBefore acting, have the model produce a list of steps, then execute them — revising the list as reality reports back.example
• SubagentThe main agent hands a subtask to a separately running agent with its own clean context; when it finishes, only the result comes back.exampledeep dive
• OrchestratorThe layer that decides which task goes to whom, in what order, and how results are collected; in a lead/worker pattern, the lead that delegates rather than does.example
• Agent memoryInformation stored outside the model — files, databases — selected and re-injected into context when needed; the model itself retains nothing across calls.exampledeep dive
• SkillA packaged, reusable capability: an instruction file for one class of task, plus optional scripts and resources, loaded by the agent only when needed.example
• Slash commandA short /command typed by the user that expands into a predefined workflow — triggered by a human, never selected by the model.example
• MCP (Model Context Protocol)An open standard for exposing tools, resources and prompt templates to AI clients — write the server once, and every MCP-compatible client can use it.exampledeep dive
• CheckpointA saved snapshot of a task half-finished, so work resumes from here after an interruption instead of restarting from zero.example
• Human-in-the-loop (HITL)A deliberately inserted point where the flow stops and waits for a human: the agent continues only after a person has looked and approved.example
• Multi-agent systemSeveral agents with divided responsibilities completing one task — collection, analysis and reporting split apart, joined by messages and shared state.example

Where the hardware bottlenecks are, and which numbers actually matter.

• GPU (graphics processing unit)A chip built to do many simple calculations at once, which is exactly the shape of work a large model needs.example
• VRAM (GPU memory)The GPU's own memory. Model weights and the KV cache must fit here first; if they do not, the model does not run.example
• FLOPS (floating-point operations per second)A raw compute number: how many floating-point operations per second. It looks the most technical, yet it predicts the speed you actually feel the worst.example
• Parameter countHow many adjustable numbers a model holds. It is often used as a label for "how big and smart" a model is, but that label misleads more often than you think.example
• Unified memory (CPU and GPU share one pool)CPU and GPU share one block of memory, with no copying between two pools. Apple Silicon is the classic example.exampledeep dive
• CPU inference (running a model without a GPU)Running a model on the CPU alone, with no GPU. For small models, low volume and offline batch work it is genuinely usable; for large models or interactive use it is essentially hopeless.example
• Local vs cloud (run it yourself or call an API)Whether the model runs on your own machine (local) or you call someone else's over the network (cloud API). The real difference is not "free vs paid" but several axes: privacy, cost at volume, latency, capability ceiling and maintenance burden.example
• TTFT (time to first token)The dead air between pressing send and the first character appearing. It is driven mainly by prompt length and prefill, and it is the number users actually experience as "lag".animatedexample
• Tokens per second (generation throughput)How many tokens a model emits per second. During decode it is set mainly by memory bandwidth, not compute; the vendor's figure and your measured figure often differ by a wide margin.example
• Concurrency (how many requests at once)How many requests a system handles at the same time. How fast one user feels it is, and how many people one machine can serve at once, are two completely different problems.example
• Batching (serving many requests together)Running several requests together to amortize the cost of hauling weights into the compute units. It raises the machine's total throughput but can lengthen any single request's latency.exampledeep dive
• KV cacheStoring each processed token's Key and Value so the next token need not recompute them. The cost: this memory grows with sequence length, which is exactly why long context is so RAM-hungry.example
• Cost per token (how API pricing actually works)APIs price input tokens and output tokens separately, output is usually dearer, and cached input is often discounted. An agent's bill is frightening because each turn it resends a longer and longer context.exampledeep dive

How outside knowledge reaches the model, and what happens when the wrong knowledge arrives.

• RAG (Retrieval-Augmented Generation)Look material up first, hand the retrieved passages to the model along with the question, and have it answer from them.exampledeep dive
• EmbeddingTurning text into a list of numbers so that "similar meaning" becomes "close in distance".example
• Vector databaseA database that searches by how close the meaning is: you give it a query vector and it returns the nearest few records, instead of matching exact wording.example
• ChunkingBefore embedding, cut long documents into small pieces; a vector compresses the meaning of a whole passage into one point, and the longer the passage, the blurrier that point.exampledeep dive
• RerankingThe second pass of retrieval: a cheap, fast method pulls a batch of candidates, then a smarter, pricier model reads the query together with each candidate to reorder them by true relevance.exampledeep dive
• Full-text searchTraditional keyword search that ranks by whether terms appear, how often, and how rare they are; the classic algorithm is BM25. It does not understand meaning — it counts words.exampledeep dive
• OCR (Optical Character Recognition)Recognising the "picture-of-text" in images, scans and PDFs into real text a computer can process; the first step for any paper document entering a data pipeline.exampledeep dive
• Structured outputAsking the model to return data that conforms to a format you specify (usually a JSON schema) instead of free prose, so downstream code can parse it directly without guessing.example
• Semantic vs keyword searchThe core trade-off between two retrieval styles: keyword matches on whether wording is identical, semantic on whether meaning is close. The former is precise but rigid; the latter is flexible but can miss the point.example
• Data pipelineA fixed chain of steps that carries data from source to usable state: ingest → clean → transform → store → serve. Almost every AI application sits on such a pipeline.example
• GroundingTying each claim the model makes back to a source the reader can verify themselves; not "it says it has a source" but "the source really exists and really supports this sentence".example

An AI that can act can also do damage. These terms are the boundary.

• Prompt injectionAn attacker hides instructions inside content the AI will read, so the AI treats data as commands.exampledeep dive
• SandboxThe fence around what an AI may touch: which folders are writable, whether it has network access, and whether it must ask you each time.example
• JailbreakUsing conversational tricks to make a model bypass its own usage rules and output what its makers never intended.example
• Data classificationSorting data by sensitivity first — public, internal, confidential, restricted — then deciding where each class may flow, including whether it may enter a model's context.example
• PII (Personally Identifiable Information)Data that identifies a specific person, alone or in combination: names, ID numbers, phone numbers, addresses, medical records, precise location…example
• De-identificationRemoving or rewriting the person-pointing parts of data so it stays analysable but (ideally) no longer reveals who it is about.example
• Red teamingDeliberately attacking your own system from the attacker's position, to find the failures before users or real attackers do.exampledeep dive
• Supply chain riskRisk that arrives not through your own code but through what you install: dependencies, plugins, third-party skills, MCP servers.example
• Audit logA tamper-evident record of behaviour: when, driven by what input, the agent called which tools with which arguments and got which results — written by the execution layer, not narrated by the model.example
• Permission gateThe decision point before an action runs: allow, ask a human, or deny — enforced by harness code, not left to the model's goodwill.example
• Verification gateAn independent check before a result is accepted: performed by a checker distinct from the producer — separate session, unshared context — against what was actually required.exampledeep dive