Going further · about 3 minutes

GenAI, solved.

Generative AI comes with a lot of jargon. This cube holds 48 of the most common terms in six families, one per colour, with the family's name in the centre. Watch it come together, then spin it and tap any square.

The cube needs JavaScript. Every term is in the text version below.

Six families

How to play

Tap any square

Each square is one term. Same colour, same family. Pick a family to light up its squares, even while the cube is scrambled.

Text version: all 48 terms

Agents

Models that act, not just answer: they call tools, keep memory and work in loops, with people at the gates.

Tool use: Letting a model call functions such as search, code execution or an API, then use the results.
MCP: Model Context Protocol: an open standard for plugging tools and data sources into any AI app.
Planning: Breaking a goal into steps before acting, and revising the plan when a step fails.
Memory: What an agent carries between steps or sessions: notes, files and summaries of earlier work.
Subagents: Helper agents that take a side task with a fresh context and report back a summary.
Computer use: An agent that works a screen directly: reading pixels, clicking and typing.
Agent loop: Think, act, observe, repeat, until the goal is met or a person needs to decide.
Human-in-the-loop: Gates where a person approves, edits or stops what the agent is about to do.

Models

What's inside: the architecture and raw ingredients every generative system is built from.

Transformers: The network design behind almost every modern language model: attention layers stacked dozens deep.
Attention: How a model decides which earlier words matter for the next one, by scoring every token against the others.
Tokens: The chunks of text a model reads and writes, roughly three quarters of a word each. You pay per token.
Embeddings: Lists of numbers that place text in a space where similar meanings sit close together.
Context window: How much text the model can see at once: its working memory for one request.
Diffusion: The technique behind most image generators: start from noise and remove it step by step.
Mixture of experts: A model split into specialist sub-networks, where only a few wake up for each token.
Multimodal: Models that take in or produce more than text: images, audio, video, screenshots.

Safety & trust

Where it goes wrong, and how teams find out before their users do.

Hallucination: Confident, fluent output that is simply wrong. Fluent isn't the same as true.
Prompt injection: Hidden instructions in a web page, email or file that try to hijack the model.
Alignment: Making a model's goals and behaviour match what people actually intend.
Red teaming: Attacking your own model on purpose to find failures before others do.
Evals: Repeatable tests that measure whether a model or prompt is good enough, and stays that way.
Bias: Skews learned from training data that show up as unfair or one-sided output.
Interpretability: Research into what happens inside the network: which features and circuits produce an answer.
Jailbreaks: Prompts crafted to talk a model out of its safety rules.

Training

How a model learns: from reading much of the internet to being taught manners.

Pretraining: Reading a huge slice of text to predict the next token. This is where general knowledge comes from.
Fine-tuning: Extra training on a smaller, focused dataset to teach a style, format or domain.
RLHF: Reinforcement learning from human feedback: people rank answers and the model learns to prefer the better ones.
Synthetic data: Training examples written by other models, used when real data is scarce, private or expensive.
Distillation: Training a small student model to imitate a big teacher, keeping much of the skill for a fraction of the cost.
Scaling laws: More data, parameters and compute improve models predictably. Until they don't.
LoRA: A cheap fine-tuning trick: train small add-on matrices instead of the whole model.
Quantization: Storing a model's numbers with fewer bits so it runs faster on smaller hardware.

Shipping

Turning a demo into a product: speed, cost, scale and being able to see what happened.

Latency: How long users wait. For chat, time to the first token matters most.
Cost per token: The unit price of AI. Input, output and cached tokens are priced differently.
Streaming: Sending the answer token by token as it's generated, so it feels instant.
Batching: Grouping many requests together: cheaper and slower, for work that isn't urgent.
Observability: Logs, traces and dashboards showing what the model was asked, what it did and what it cost.
Rate limits: Caps on requests or tokens per minute. Plan for them before launch day.
Model routing: Sending easy requests to small, cheap models and hard ones to big models.
Guardrails: Checks around the model that block unsafe input or output before it reaches users.

Prompts & context

What you put in decides what you get out.

System prompt: Standing instructions that set the model's role, rules and tone for a whole conversation.
Few-shot: Showing a few worked examples in the prompt so the model copies the pattern.
Chain of thought: Letting the model reason step by step before it answers. Helps on multi-step problems.
Structured output: Asking for JSON or another fixed format so code, not people, can read the answer.
Temperature: The randomness dial. Low gives repeatable answers, high gives varied ones.
Prompt caching: Reusing the processed start of a prompt across requests, so long shared context gets cheaper and faster.
RAG: Retrieval-augmented generation: look up relevant documents first, then answer from them.
Vector search: Finding text by meaning rather than exact words, by comparing embeddings.