AI Explained Simply: 28 Questions Answered at Three Levels

Twenty-eight common questions about AI, each answered three times over: a picture you will not forget, where the idea already touches your day, and the mechanics underneath. Read only as deep as you need.

Published 2026-09-05 · By Shahzad Asghar

Every answer on this page comes in three layers. The first paragraph gives you the answer in under a minute. The simplest picture uses one everyday image you will not forget. In everyday life shows where the idea already touches your day. Under the hood is for readers who want the mechanics. Read only as deep as you need, and come back for the next layer another day.

1. What is artificial intelligence (AI)?

Artificial intelligence is software that learns to do a task from examples instead of following step-by-step instructions written by a person. A calculator follows a fixed set of rules. An AI that filters spam, reads X-rays or answers questions learned those skills by studying millions of examples.

The simplest picture

Imagine two cooks in a kitchen. The first cook can only follow a recipe card, word for word. Change one ingredient and he is lost. The second cook learned by tasting thousands of dishes. Give her a recipe she has never seen and she still makes something good.

Old computers are the first cook. They do exactly what the recipe says and nothing more.

AI is the second cook. Nobody wrote a recipe for "recognise Grandma's face". The computer was shown thousands of faces until it worked out the pattern on its own, the same way you learned to know your mother's voice without anyone explaining how.

In everyday life

Every AI you meet in daily life is a pattern-finder that was trained on examples.

• Your spam folder. The filter was shown millions of emails marked "spam" or "not spam" and learned what spam looks like.
• Your bank blocking a card payment at 3 a.m. It learned your normal pattern and noticed the exception.
• A hospital scanner flagging a possible tumour. It studied thousands of X-rays that doctors had already labelled.
• A chat assistant answering your question. It learned the patterns of language from more text than any person could read in a lifetime.

Here is where it started for most of us, without anyone noticing. In the 1990s, post offices were drowning in handwritten envelopes. Nobody could write a rule for every way a person scribbles a 7. So engineers stopped writing rules and instead showed a computer thousands upon thousands of handwritten digits, each with the correct answer attached. The machine was never told what a 7 looks like. It worked it out. Within a few years, a large share of handwritten mail was being read by a machine that had learned from examples: the second cook in the kitchen.

Two things worth keeping in mind. First, an AI is only as good as its examples. Feed it thin or lopsided examples and it will be wrong with great confidence. Second, it recognises patterns; it does not understand the way you do.

Under the hood

In its modern form, AI means machine learning, and machine learning is function approximation. You have inputs x, desired outputs y, and a model f(x; θ) with adjustable parameters θ. You define a loss function that measures the gap between f(x) and y across a training set, then run an optimiser, usually a form of gradient descent, to adjust θ until that gap is small.

The recipe cook is a hand-written algorithm: the programmer specifies the mapping from input to output. The example-taught cook is a learned mapping: the parameters that define it were discovered from data, not written.

Three consequences follow, and most AI governance questions trace back to one of them:

• Generalisation versus memorisation. A model that scores well on its training data but poorly on unseen data has overfit. Held-out validation exists to catch this.
• Data bounds the model. Bias, gaps or noise in the training set become bias, gaps or noise in the behaviour, at scale and with a straight face.
• The learned mapping is opaque. Billions of parameters encode the pattern, but not in a form a human can read, which is why explainability and accountability are hard.

A large language model is one instance of this: f predicts the next token in a sequence, θ runs into the billions, and the training set is a very large corpus of text.

Remember it like this: old computers follow recipes; AI learns from examples.

Quick check: your pocket calculator and your phone's face unlock. Which one learned from examples? (Face unlock. The calculator is following a recipe.)

Related: Q15 How is AI different from if-then programming? · Q4 Generative AI vs AI · Q13 How models are trained

2. Was artificial intelligence invented in 2023?

No. The term was coined in 1956, and the ideas go back to Alan Turing in 1950. What happened in late 2022 and 2023 is that AI became easy for ordinary people to use through ChatGPT. Think of electricity: it existed for a century before the wall socket put it in every home.

The simplest picture

Electricity was understood in the 1800s. Factories ran on it. But for most families, electricity "arrived" the day a socket appeared in the kitchen wall.

AI is the same. Scientists built it for seventy years. In November 2022 a free chat box appeared on a website, and anyone could type a question in plain words. That was the socket in the wall, not the invention of electricity.

In everyday life

The short history, in plain words:

• 1950: Alan Turing asks whether machines can think and proposes a test.
• 1956: a summer workshop at Dartmouth College gives the field its name.
• 1997: a chess computer beats the world champion, Garry Kasparov.
• 2012: a network taught with examples learns to recognise objects in photos far better than anything before it.
• 2017: Google researchers publish the "transformer" design that sits inside every modern chatbot.
• November 2022: ChatGPT is released. It reaches an estimated 100 million users in about two months, faster than any consumer app before it.

You had already been using AI for twenty years without calling it that: the spam filter since the early 2000s, the traffic colours on your map, the fraud check on your card, and the post office reading your handwriting since the 1990s. What 2023 changed was that AI started talking back, and a machine that holds a conversation feels intelligent in a way a spam filter never did.

Under the hood

The decade before ChatGPT did the real work. Deep learning revived in 2012 when GPUs met large labelled datasets. The transformer (2017) replaced recurrent networks with attention, which trains in parallel and therefore scales. Scaling laws (2020, 2022) showed that loss falls predictably as parameters, data and compute grow, which made large investments rational. Finally, instruction tuning and reinforcement learning from human feedback (2022) turned a raw next-word predictor into an assistant that follows instructions.

ChatGPT itself introduced no new algorithm. It was GPT-3.5, aligned with human feedback, behind a chat interface with no setup. The novelty was packaging and distribution, not discovery.

Remember it like this: AI was not born in 2023; it got a wall socket.

Quick check: which came first, the spam filter or ChatGPT? (The spam filter, by about twenty years.)

Related: Q5 Why did AI boom in 2023? · Q3 Is ChatGPT the same as AI? · Q19 GPUs, from games to AI

3. Is ChatGPT the same as AI, and did OpenAI invent AI?

ChatGPT is one AI product: a chat program built on OpenAI's large language models. It is not AI itself, and OpenAI did not invent AI. It built an unusually usable product on decades of research by many labs, including Google, whose researchers published the transformer design that ChatGPT depends on.

The simplest picture

Toyota did not invent the car. But the Corolla put millions of ordinary families behind the wheel.

ChatGPT is the Corolla of AI: not the first, not the only one, but the one that made it feel normal. AI is the whole road system. ChatGPT is one car on it.

In everyday life

ChatGPT is two things bolted together: a chat window you type into, and a large language model behind it that produces the reply. OpenAI makes the model and the window.

Other cars on the same road: Claude (Anthropic), Gemini (Google), Copilot (Microsoft, which runs on OpenAI models), Llama (Meta), and Qwen and DeepSeek (China). And most AI is not a chatbot at all: the fraud model at your bank, the map that predicts your arrival time, the photo app that groups your grandchildren's faces.

The part few people know: in 2017, eight Google researchers published a paper called "Attention Is All You Need". It described the transformer. The T in GPT stands for Transformer. The engine inside ChatGPT was designed in Google's workshop; OpenAI built the car around it and opened the showroom to the public.

Under the hood

GPT means Generative Pre-trained Transformer: a decoder-only transformer, pre-trained on next-token prediction over a web-scale corpus, then instruction-tuned and aligned with human feedback. ChatGPT is that model plus a chat template, a system prompt, tools such as web search and code execution, safety layers and a product interface.

The lineage has no single inventor: Turing (1950), the perceptron (1958), backpropagation (1986), LSTMs (1997), word embeddings (2013), attention (2014 to 2015), the transformer (2017), GPT-1 and BERT (2018), GPT-2 (2019), GPT-3 (2020), InstructGPT (early 2022), ChatGPT (November 2022). OpenAI's contribution was scale, alignment and product execution, all of which mattered enormously; invention was collective.

Remember it like this: ChatGPT is a car; AI is the road system.

Quick check: what does the T in GPT stand for, and who published that design? (Transformer, published by Google researchers in 2017.)

Related: Q1 What is AI? · Q2 Was AI invented in 2023? · Q6 Model names explained

4. What is the difference between generative AI and AI?

AI is the whole family of software that learns from examples. Generative AI is the branch that produces new content: text, images, code, audio and video. Older AI mostly judged or sorted things (is this spam? is this a cat?). Generative AI creates things. All generative AI is AI; most AI is not generative.

The simplest picture

A bank teller and a novelist. The teller looks at your cheque and decides: genuine or forged. That is judging AI. The novelist writes a story nobody has read before. That is generative AI.

Both are clever. They do different jobs. Before 2022, nearly every AI you met was the teller.

In everyday life

Judging AI (the teller): spam filters, fraud checks, face unlock, a scanner flagging a suspicious X-ray, the app choosing which film to recommend. Each one gives a decision, a score or a label.

Generative AI (the novelist): ChatGPT and Claude writing a memo, an image tool painting a picture from a sentence, a voice clone, a coding assistant writing the program.

A field office might use both in one morning. The teller sorts ten thousand community feedback messages into topics. The novelist drafts the weekly summary in Arabic and English. The risk is different too. A teller's yes or no can be checked against the facts. A novelist writes fluently, and fluent text can be wrong. Generative output needs a human reader.

The surprise: the same mathematics powers both. The difference is what the model was trained to produce.

Under the hood

The statistical distinction is discriminative versus generative. A discriminative model learns P(y | x), a boundary between classes, and is evaluated on accuracy against labels. A generative model learns a distribution over the data, P(x) or P(x | prompt), and samples from it, so evaluation shifts to quality, faithfulness and diversity of open-ended output.

Large language models are autoregressive generative models over token sequences. Diffusion models generate images by learning to reverse a noising process. In practice the line blurs: LLMs are routinely used for classification via prompting, and discriminative heads are trained on generative backbones. The governance difference remains: discriminative errors are measurable against a label; generative errors (hallucination, fabrication) require reference-free or human evaluation.

Remember it like this: old AI judges; generative AI creates.

Quick check: face unlock on your phone, judging or generating? (Judging.)

Related: Q1 What is AI? · Q12 Multimodal AI · Q13 How models are trained

5. AI has existed for fifty years. Why did it boom in 2023?

Four things lined up at once. Enough data (most of the internet), enough computing power (GPUs), a design that keeps improving as it grows (the transformer, 2017), and a front door anyone could walk through (ChatGPT, free, in plain conversation). The science was ready earlier. 2023 was the year the public got a door handle.

The simplest picture

Bread. To bake a great deal of bread you need flour, a hot oven and a recipe that still works when you make it bigger.

For decades AI had a little flour (small data), a weak oven (slow computers) and recipes that fell apart when scaled up. By 2020 the flour was there (the internet), the oven was hot (GPUs) and a new recipe (the transformer) got better the bigger you made it. Then, in November 2022, the bakery opened its front door and gave the bread away. That was ChatGPT. The queue formed in 2023.

In everyday life

Most technology stops improving as it gets bigger. These models did not. Every time a company doubled the data and the computing power, the model got noticeably better. That is why the race to build larger models began, and why the electricity bills followed.

The front door mattered as much as the oven. Earlier AI needed a programmer to use it. ChatGPT needed a sentence. The model inside it, GPT-3, had been available to developers since 2020 and most of the world had never heard of it. The chat box changed that. Analysts estimated ChatGPT reached 100 million users in about two months; Instagram had taken more than two years.

One more ingredient is human. A spam filter never made anyone feel they were talking to a mind. A chatbot that answers back does. We are wired to treat conversation as intelligence, so the moment AI spoke, it felt as if it had arrived.

Under the hood

The compounding factors, in order of arrival. Data: web-scale corpora such as Common Crawl, trillions of tokens after filtering and deduplication. Compute: GPU clusters, mixed-precision training and model parallelism, with cost per unit of compute falling for a decade. Architecture: transformer attention is parallel across sequence positions, so training saturates GPUs where recurrent networks could not. Predictability: scaling laws (Kaplan et al. 2020; Hoffmann et al. 2022) turned spending into a forecast. Usability: instruction tuning and RLHF converted a next-token predictor into an assistant. Distribution: a consumer chat interface with zero setup and no cost.

No single discovery happened in 2023. A decade of enabling work crossed a usability threshold.

Remember it like this: flour, oven, recipe, front door.

Quick check: which of the four ingredients arrived last? (The front door: the chat interface.)

Related: Q2 Was AI invented in 2023? · Q19 GPUs, from games to AI · Q13 How models are trained

6. What are these model names: GPT-3, Solar, Flash?

They are product names, like car names. A model name usually tells you the maker, the family, the generation and the size or speed tier. GPT-3 is OpenAI's third-generation GPT model (2020). Gemini Flash is Google's fast, cheaper tier. Solar is a family of models from Upstage, a South Korean company.

The simplest picture

Read a model name the way you read a car badge: Toyota (maker), Corolla (family), 2020 (generation), Hybrid (variant).

GPT-3 is OpenAI, GPT family, third generation. Gemini 2.5 Flash is Google, Gemini family, version 2.5, Flash trim (fast and cheap). Claude Haiku, Sonnet and Opus are Anthropic's small, medium and large trims. Once you see the pattern, the names stop being frightening.

In everyday life

The words that tell you the size and speed:

• Small, fast, cheap, less clever: Nano, Mini, Flash, Haiku, Lite.
• Middle: Pro, Sonnet, and most numbered models with no suffix.
• Largest and most capable: Ultra, Opus, Max.

The words that tell you the variant: "Instruct" or "Chat" (trained to follow instructions), "Vision" (can see images), "Turbo" (a faster version), "Thinking" or "Reasoning" (spends longer working before answering). Numbers such as 8B or 70B tell you the size in billions of parameters (see Q14).

A practical rule. For routine writing and summarising, the middle trim is usually enough. Pay for the top trim when the task is hard or the cost of a mistake is high. Translating a routine notice: a Flash-class model is fine. Drafting a legal position: use the largest one and read it carefully.

The surprise: the small, fast trims are often taught by the big ones. A large model answers thousands of questions and a small model is trained to imitate it, a process called distillation.

Under the hood

Tiers differ in parameter count, training compute, context window, price per million tokens and sometimes architecture (dense versus mixture-of-experts). Version numbers are marketing rather than semantic versioning; a ".5" may be a full re-training. The facts that matter live in the model card and API documentation: context length, input modalities, knowledge cutoff, pricing, latency and benchmark results. Open-weight names add parameter counts and quantisation, for example "Llama 3 8B Instruct, 4-bit".

Remember it like this: maker, family, generation, trim.

Quick check: in "Gemini 2.5 Flash", which word tells you it is the fast, cheaper tier? (Flash.)

Related: Q14 What 8B and 70B mean · Q8 Who decides which model is best? · Q7 Benchmarks

7. What are AI benchmarks?

Benchmarks are standardised exams for AI models. Every model sits the same test, so scores can be compared: multiple-choice knowledge across 57 subjects (MMLU), school maths (GSM8K), coding (HumanEval, SWE-bench), graduate-level science (GPQA). They are useful, imperfect and can be gamed, exactly like exams.

The simplest picture

Every year, school children across a country sit the same exam so schools can be compared. AI benchmarks are the same idea: a fixed set of questions with known answers. A new model sits the exam, and the percentage correct is its score.

The catch is the one every teacher knows. A school can teach to the test.

In everyday life

How to read a score. A jump from 60 to 90 on a knowledge exam is meaningful. A difference of 89 versus 90 is noise, whatever the launch announcement says.

What benchmarks do not measure: honesty, how the model behaves with your own documents, quality in Arabic, tone with a nervous citizen, and whether it admits what it does not know.

If a ministry is choosing a chatbot for citizen services, the benchmark that matters is one it builds itself: two hundred real questions from real citizens, with answers a supervisor has approved. That exam costs a week and tells you more than every published leaderboard.

The surprise: some benchmark questions are copied so widely across the internet that they leak into training data. The model has, in effect, seen the exam paper. Researchers call this contamination.

Under the hood

Benchmark families: static question sets with exact-match scoring; generative tasks with automatic graders (unit tests for code); human preference comparisons; and agentic evaluations where the model must complete tasks in an environment. Known problems: contamination, saturation as models reach the ceiling, sensitivity to prompt wording and few-shot format, and differences between evaluation harnesses that make published numbers hard to reproduce.

Good practice for a deployment decision: a private held-out set drawn from the real task distribution, decontamination checks, reporting variance across runs, and language-specific evaluation rather than translated English sets. For the Arab region, Arabic-native benchmarks matter more than headline global scores.

Remember it like this: benchmarks are exams, and exams can be crammed for.

Quick check: two models score 88 and 89 on the same exam. Which is better? (You cannot tell; the gap is within noise.)

Related: Q8 Who decides which model is best? · Q6 Model names explained · Q11 Chinese AI models

8. Who decides which AI model is best?

Nobody, officially. Rankings come from three sources: standardised benchmark exams, public blind comparisons where thousands of users vote between two anonymous answers (LMArena, formerly Chatbot Arena), and each organisation's own tests on its own work. Only the third one is a ranking for you.

The simplest picture

Restaurant ratings. Inspectors score the kitchen against a checklist. Diners vote for the meal they preferred without knowing which chef cooked it. And then there is your own tongue.

A restaurant can top both lists and still not suit your family. "Best model" works the same way. Taste it on your own work.

In everyday life

The inspectors are the benchmarks (Q7). The diners are LMArena, where a person types a question, sees two unnamed answers, picks the better one, and only then learns which models they were. Millions of such votes produce a league table. Sites such as Artificial Analysis rank models on speed and price as well.

Why the table changes every month: new models arrive weekly, and every company's launch post shows charts in which it wins. Read those charts the way you read a car advertisement.

Your own tongue, in practice: pick twenty real tasks from your desk (a memo to draft, a page to translate, a long PDF to summarise, three questions you know the answers to). Run them through three models. Score them with a colleague. That afternoon of work is the only "best" that counts, and a cheaper model often wins it.

Under the hood

Arena rankings aggregate pairwise human votes with Bradley-Terry or Elo-style models; known biases include preference for longer and more confident answers, and style over substance. Benchmarks and preference votes measure different things and disagree regularly.

A rigorous selection process: define the task distribution, build a labelled evaluation set, choose metrics (exact match, rubric grading, calibrated LLM-as-judge), measure cost and latency, test robustness to prompt variation and adversarial input, check language coverage, then re-run whenever a model version changes. Procurement should require reproducible evaluation on the buyer's data, not the vendor's chart.

Remember it like this: inspectors, diners, your own tongue.

Quick check: which of the three ranking sources should decide your purchase? (Your own tests.)

Related: Q7 Benchmarks · Q6 Model names explained · Q24 AI engineering or AI governance?

9. What is an embedding in AI?

An embedding turns a word, sentence, image or document into a list of numbers that act like coordinates on a map of meaning. Things with similar meaning land close together. It lets a computer measure how alike two pieces of text are, even when they share no words.

The simplest picture

Imagine a library where books are shelved not by alphabet but by meaning. "Rain", "umbrella" and "flood" sit near each other. "Rain" and "rainbow" are further apart than their spelling suggests.

An embedding is the shelf address of each word or sentence. The computer cannot understand "flood". It can measure that its address is next door to "rain".

In everyday life

You meet embeddings whenever a computer finds something by meaning rather than by exact words: a search that returns "heart attack" when you typed "cardiac arrest", a photo app that groups the same face across ten years, a shop suggesting what you might also like, an office document search that finds the right report in Arabic when you searched in English.

A humanitarian team once kept fifty thousand field reports. Keyword search missed the Arabic reports that described displacement in different words. An embedding search found them, because it compared meaning, not spelling.

The surprise: on such a map you can do arithmetic with words. Take the address of "king", subtract "man", add "woman", and you land next to "queen". That result, from 2013, was the moment many researchers realised meaning could be measured.

Under the hood

An embedding model maps an input to a dense vector, typically 256 to 3,072 dimensions. Similarity is cosine similarity or a dot product. Embeddings are learned with objectives that pull related pairs together and push unrelated pairs apart (contrastive learning), or taken from the hidden states of a language model. They are stored in vector indexes (FAISS, pgvector, and hosted services) with approximate nearest-neighbour search such as HNSW. Multilingual embedding models place an Arabic sentence and its English translation close together, which is the basis of cross-lingual search.

Remember it like this: an embedding is an address on a map of meaning.

Quick check: two sentences share no words but mean the same thing. Will their embeddings be close or far apart? (Close.)

Related: Q26 Embeddings in search and RAG · Q20 Are chatbots just RAG? · Q22 Arabic and other languages

10. What are weights in an AI model?

Weights are the numbers inside a model that training adjusts. Think of billions of tiny dials. Before training, the dials are set at random and the model produces nonsense. Training turns them, a little at a time, until the outputs are useful. The finished dial settings are the model's knowledge.

The simplest picture

A recording studio mixing desk with a thousand sliders. A raw song sounds muddy. The engineer nudges sliders for hours until it sounds right. He does not write down rules. He listens and adjusts.

AI training is that, with billions of sliders and a machine doing the nudging. When the sliders are set, you can copy the settings onto another desk and get the same sound. That copy is "the model".

In everyday life

This is why you hear the phrase "open weights". Meta's Llama, Alibaba's Qwen and DeepSeek publish their slider settings, so anyone can download them and run the model on their own computers. OpenAI and Google keep most of theirs private, so you can only use their models through their services.

It also explains two things people find odd. A model's knowledge stops at a date, because the sliders stop moving when training ends. And nobody can open a model and read what it knows, because the knowledge is spread across all the sliders at once, not written anywhere.

A ministry that needs its data to stay inside the country downloads open weights and runs them on its own servers. That is sovereignty in practice.

The surprise: a model file contains no text at all. A 70-billion-parameter model is roughly 140 gigabytes of decimal numbers and nothing else.

Under the hood

Weights are the parameters of the network's linear maps: embedding matrices, attention projections (query, key, value, output) and feed-forward layers, plus normalisation parameters. They are stored as tensors in 16-bit floating point and often quantised to 8-bit or 4-bit integers for serving. Training updates them by backpropagation and gradient descent on a loss. Fine-tuning updates a subset or adds low-rank adapters (LoRA). "Open weights" is not "open source": the weights are released, but the training data and code usually are not. The distributed nature of weights is why model auditing relies on behavioural evaluation rather than inspection.

Remember it like this: weights are the slider settings that training found.

Quick check: if you copy a model's weights to another computer, what do you get? (The same model.)

Related: Q14 What 8B and 70B mean · Q13 How models are trained · Q25 Which programming language? How LLMs work: weights, RAG and fine-tuning

11. Why are Chinese AI models so good?

Because China has a very large pool of AI researchers, enormous data and a huge home market, fierce competition among many labs, and strong state backing. Restrictions on buying the most advanced chips pushed its labs toward cheaper, more efficient training methods, and several labs release their weights openly, which spread adoption worldwide.

The simplest picture

A national team training on a smaller budget. When you cannot buy the best equipment, you get better at the drills.

Chinese labs such as DeepSeek and Alibaba's Qwen team could not buy the top graphics chips. So they found ways to train with less. Then they published how they did it and gave the models away, and everyone tried them.

In everyday life

The moment most people noticed was January 2025. DeepSeek released a reasoning model, R1, that matched leading American models on many tests, said it had been trained at a small fraction of the usual cost, and gave the weights away. Nvidia's shares fell sharply in a single day.

The names to know: DeepSeek; Qwen (Alibaba); Kimi (Moonshot); GLM (Zhipu); Doubao (ByteDance). Because Qwen is free and strong in many languages, developers everywhere, including across the Arab region, build on it. It has been among the most downloaded open model families in the world.

Two cautions belong beside the praise. These models are trained under domestic content rules, so answers on some political topics are restricted or slanted. And the training-cost claims are hard to verify independently. For public-sector use, run them on your own servers and evaluate them like any other model (Q8).

Under the hood

DeepSeek's efficiency techniques are now widely copied: mixture-of-experts (only a fraction of parameters active per token), multi-head latent attention (a much smaller memory cache), FP8 mixed-precision training, and reinforcement learning with verifiable rewards for reasoning (GRPO), followed by distillation into small dense models. Structural factors: deep graduate pipelines, industrial clusters that turn research into products fast, and an open-weight strategy that captures the developer ecosystem. Export controls on H100-class accelerators shaped design choices toward compute efficiency. Governance questions differ by jurisdiction: training-data transparency, content-policy alignment and model provenance all need evaluation before deployment.

Remember it like this: constraint bred efficiency, and giving it away spread it.

Quick check: what pushed Chinese labs to train more efficiently? (Limits on buying the most advanced chips.)

Related: Q8 Who decides which model is best? · Q10 Weights · Q13 How models are trained

12. How is multimodal AI different?

A text-only model reads and writes words. A multimodal model also takes in images, audio or video, and sometimes produces them. It is one model with more senses, not several models glued together. That is why you can photograph a form and ask the AI what it says.

The simplest picture

Two assistants. One is brilliant but blindfolded and can only read what you type. The other can see the photo you hold up, hear you speak and read your notes. Same brain, more senses. Multimodal means the second assistant.

In everyday life

What it lets you do: photograph a prescription, a handwritten letter or a whiteboard and ask what it says; show it a chart and ask what changed; speak to it instead of typing; and, with some models, ask for a picture or a short video in return.

A field officer photographs a damaged bridge. The model describes the damage, estimates the span affected and drafts the incident report. Ten minutes instead of an afternoon.

The limits: it can misread a number in a blurry photo and never say so. It "sees" the way it reads, by pattern, not by careful inspection. Check every figure that matters.

The surprise: to the model, a picture is chopped into small squares that become tokens, the same kind of thing as words. It reads a photo the way it reads a sentence.

Under the hood

Each modality has an encoder (a vision transformer for images, an audio encoder for speech) that maps input into the same embedding space as text tokens. Early-fusion models are trained natively on interleaved text, image and audio data; late-fusion models attach a vision encoder to an existing language model through a small projector. Output can be text through the language head, or images through diffusion or discrete visual tokens. Trade-offs: image resolution versus token cost, hallucination on fine detail, and evaluation that is harder than for text alone. Governance: image and voice inputs raise privacy and safety issues (faces, identity documents, biometrics) that text-only deployments never had.

Remember it like this: multimodal is the same brain with more senses.

Quick check: you photograph a handwritten letter and ask what it says. Which kind of model do you need? (A multimodal one.)

Related: Q4 Generative AI vs AI · Q9 Embeddings · Q28 Tokens per second

13. How do AI companies train their models?

In three stages. First, pre-training: the model reads trillions of words and learns to predict the next word. Second, fine-tuning: it is shown thousands of example conversations to learn to be helpful. Third, feedback training: people rate its answers and it is adjusted toward the preferred ones. The whole process takes months and reportedly costs tens to hundreds of millions of dollars.

The simplest picture

Raising a doctor. Medical school: read everything (pre-training). Residency: watch good doctors handle real patients and copy them (fine-tuning). Then years of patient feedback: this bedside manner works, that one does not (feedback training).

Nobody wrote a rulebook for "being a good doctor". The doctor was grown from examples and feedback. So was the model.

In everyday life

Stage one explains why the model seems to know everything and yet stops at a date. It read the public internet, books, code and licensed material up to a cutoff, then the reading stopped.

Stage two is why it answers in tidy paragraphs and follows instructions. It was shown examples of good answers.

Stage three is why it is polite, refuses some requests and formats its replies. Human raters compared pairs of answers for months, and the model was pushed toward what they preferred. Newer "reasoning" models add a fourth stage: they practise maths and coding problems where the answer can be checked automatically, and get better at working step by step.

The scale: thousands of graphics chips running for months, with reported costs above 100 million dollars for the largest models.

The surprise: the first and biggest stage has no teacher at all. The text is its own answer key. Cover the next word, guess it, check, adjust, repeat trillions of times.

Under the hood

Pre-training is self-supervised next-token prediction with a cross-entropy loss over a curated, deduplicated web-scale corpus, run with data, tensor and pipeline parallelism across thousands of accelerators in mixed precision. Post-training: supervised fine-tuning on instruction data; preference optimisation through RLHF (reward model plus PPO) or direct methods such as DPO; AI-generated feedback in some pipelines; and reinforcement learning with verifiable rewards for reasoning. Then evaluation, red-teaming, safety training and distillation into smaller tiers. Models do not learn from your conversations in real time; updates are new training runs.

Remember it like this: medical school, residency, patient feedback.

Quick check: in which stage does the model learn most of its knowledge? (Pre-training.)

Related: Q16 Training techniques · Q10 Weights · Q14 What 8B and 70B mean

14. What do parameters like 8B or 70B mean?

The number of adjustable dials (weights) in the model. 8B means eight billion; 70B means seventy billion. More parameters usually means more capability, but also more memory, more cost and slower answers. An 8B model runs on a good laptop. A 70B model needs a server. Frontier models run into the hundreds of billions or more.

The simplest picture

Count the sliders on the mixing desk from Q10. An 8B model has eight billion of them. Think of it as the amount of wiring in the model's brain.

More wiring can hold more, but needs a bigger room and more electricity. And bigger is not always better. A well-trained small model beats a badly trained big one, the way a well-coached school team beats a lazy professional side.

In everyday life

Rough sizes and where they live:

• 1B to 4B: phones and quick tasks.
• 7B to 9B: a good laptop; a capable assistant for summaries and drafts.
• 30B to 70B: a server; close to the best models on many tasks.
• 200B and up: a data centre.

Memory rule of thumb: about 2 gigabytes of memory per billion parameters at the usual 16-bit precision, and about a quarter of that when the model is "quantised" (compressed). So an 8B model needs roughly 16 GB, or 4 to 5 GB compressed.

An NGO with no cloud budget can run an 8B model that handles Arabic on one workstation and summarise its own documents without sending them anywhere.

The surprise: some models advertise a giant total (671B) but use only a slice of it (37B) for each word. These "mixture of experts" models run far cheaper than the headline number suggests.

Under the hood

Parameter count is the total of learnable weights across embeddings, attention projections, feed-forward blocks and normalisation. Memory is parameters times bytes per parameter (2 in bf16, about 0.5 in 4-bit) plus a KV cache that grows with context length and batch size. Compute per generated token is roughly two floating-point operations per active parameter. Chinchilla-style scaling suggests about twenty training tokens per parameter for compute-optimal training, but production models are deliberately over-trained on far more tokens so that small models become strong. Mixture-of-experts separates total parameters from active parameters, which is why the two numbers are now reported separately.

Remember it like this: B is billions of dials; bigger costs more to run.

Quick check: which fits on a laptop, 8B or 70B? (8B.)

Related: Q10 Weights · Q13 How models are trained · Q17 CPUs and GPUs

15. How is AI different from classical if-then programming?

In classical programming a person writes every rule: if the email contains "lottery", mark it as spam. In AI, the person supplies examples and the computer works out the rules itself. Rules are exact and explainable but break on anything unforeseen. Learned models handle messy, unforeseen input but are approximate and hard to explain.

The simplest picture

The two cooks again (Q1), but watch what happens when the world changes.

The spam rulebook grew to thousands of if-then lines, and the spammers learned every one of them. The learned filter simply looked at the newest examples and adjusted. If-then is a rulebook. AI is experience.

In everyday life

Rules are still the right tool for many things: tax calculations, payroll, eligibility checks, anything that must be exact, auditable and identical every time. Nobody wants a tax bill that is "probably right".

AI is the right tool when nobody can write the rules: recognising a face, reading handwriting, translating, spotting a fraud pattern that has never appeared before.

The story worth knowing is the 1980s. Companies built "expert systems" by hiring specialists to write thousands of medical or banking rules. The systems worked until reality did not match the rulebook, then failed badly, and the money dried up. That collapse is what people mean by an "AI winter".

The surprise: most working systems today are both. A learned model flags a suspicious transaction; a written rule blocks anything above a threshold; a human reviews the rest.

Under the hood

Symbolic systems are deterministic and verifiable, but rule sets grow combinatorially with the number of conditions, and every edge case must be anticipated by a person. Statistical learning induces a decision function from data, tolerates noise and covers cases nobody wrote down, but fails under distribution shift, inherits data bias, and can be non-deterministic at inference. Practical architectures are hybrid: validators, business rules and guardrails wrapped around model outputs, and neuro-symbolic methods that combine both. Governance implication: rules can be audited line by line; models need statistical evaluation and ongoing monitoring.

Remember it like this: rules you write; patterns it finds.

Quick check: calculating your income tax, rules or AI? (Rules.)

Related: Q1 What is AI? · Q4 Generative AI vs AI · Q16 Training techniques

16. What are the different techniques for training AI?

The main ones: supervised learning (examples with correct answers), unsupervised learning (find structure with no answers given), self-supervised learning (the data supplies its own answers, which is how language models are pre-trained), reinforcement learning (learn from rewards), and fine-tuning or transfer learning (adapt an already trained model to a new job).

The simplest picture

Five classrooms.

In the first, the teacher hands out an answer key (supervised). In the second, the children sort a drawer of buttons into piles with no instructions (unsupervised). In the third, they cover the last word of a sentence and guess it (self-supervised). In the fourth, a puppy gets a treat every time it sits (reinforcement). In the fifth, a qualified doctor spends six months specialising in eyes (fine-tuning).

In everyday life

Where each one shows up:

• Answer key: spam filters, X-ray readers, fraud detection.
• Sorting buttons: grouping customers, spotting unusual transactions.
• Hidden word: how ChatGPT, Claude and Gemini learned language.
• Puppy treat: game-playing systems, robots, and the training that makes "reasoning" models good at maths.
• Specialising: teaching an existing model your organisation's documents, terminology and tone.

A sixth worth knowing is distillation: a big model answers thousands of questions and a small model is trained to imitate it, which is how the cheap "Flash" and "Mini" tiers are made.

A ministry does not train a model from scratch. It takes an open model and specialises it on five thousand past citizen letters and approved replies. Weeks, not years.

The surprise: the largest models learned almost everything they know with no human-written answers at all. The hidden-word classroom did the heavy lifting.

Under the hood

Supervised learning fits labelled pairs with losses such as cross-entropy or mean squared error. Unsupervised methods cover clustering, dimensionality reduction and density estimation. Self-supervised objectives include next-token prediction, masked-token prediction and contrastive learning. Reinforcement learning optimises a policy against a reward; for language models this means RLHF, DPO and related preference methods, plus reinforcement learning with verifiable rewards. Transfer learning ranges from full fine-tuning to parameter-efficient methods (LoRA, QLoRA) and instruction tuning. Distillation trains a student on a teacher's outputs or logits. Semi-supervised, active and federated learning address label scarcity and privacy. The choice is driven by label availability, data volume and the task.

Remember it like this: answer key, sorting buttons, hidden word, puppy treat, specialising.

Quick check: a model learns by covering the next word and guessing it. Which technique? (Self-supervised.)

Related: Q13 How models are trained · Q15 If-then vs AI · Q21 Building your own model

17. I have always used CPUs. Where did GPUs come from, and how do they work?

A CPU is a few very fast, very flexible cores that do tasks one after another. A GPU is thousands of small, simple cores that do the same operation on thousands of numbers at once. GPUs were built in the 1990s to colour millions of screen pixels for games, and that same trick, many identical calculations at once, is exactly what AI needs.

The simplest picture

A professor and a stadium full of schoolchildren. Give the professor any problem and he solves it, but one at a time. Give the stadium ten thousand simple additions and every child does one, all in the same second.

The professor is the CPU. The stadium is the GPU. Colouring a screen is ten million tiny sums. So is running an AI model.

In everyday life

Your laptop already has both. The CPU runs your email and spreadsheets. The GPU draws the screen and, increasingly, runs AI. Nvidia sells GeForce cards to gamers and H100 and B200 chips to data centres; AMD competes; Google builds its own TPUs.

The story. In 1999 Nvidia launched the GeForce 256 for gamers and coined the word GPU. Around 2007 it released CUDA, which let scientists use the card for general mathematics instead of pictures. In 2012 a graduate student trained an image-recognition network on two gaming cards, reportedly in his bedroom, and beat every rival by a wide margin. The stadium had found a second job.

This is why "GPU shortage" makes the front page, why AI data centres need so much electricity and cooling, and why access to chips became a matter of national policy.

The surprise: the company that powers most of the AI industry made its name selling to teenagers playing video games.

Under the hood

A CPU has few cores with large caches, branch prediction and out-of-order execution, optimised for low latency on serial code. A GPU executes thousands of threads in lock-step groups, with high-bandwidth memory and dedicated tensor cores for low-precision matrix multiplication, optimised for throughput on data-parallel work. Programming goes through CUDA or ROCm and libraries such as cuBLAS and cuDNN; frameworks compile models into these kernels. The bottlenecks are memory bandwidth and, for multi-GPU training, the interconnect (NVLink, InfiniBand). Alternatives include TPUs and purpose-built inference chips.

Remember it like this: CPU is a professor; GPU is a stadium.

Quick check: ten million identical tiny sums, professor or stadium? (Stadium, the GPU.)

Related: Q18 Why AI runs well on GPUs · Q19 GPUs, from games to AI · Q27 Inference

18. Why does AI run so well on GPUs?

Because almost everything an AI model does is one simple operation repeated on enormous grids of numbers: multiply and add. A GPU does thousands of those at the same moment. A CPU would do them one by one and take hundreds of times longer. AI did not need a new kind of chip. It needed the one the games industry had already built.

The simplest picture

Back to the stadium (Q17). Running a model means multiplying huge grids of numbers together, millions of times. Every multiplication is easy, and none of them waits for another to finish. So they can all happen at once. That is a stadium job, not a professor job.

In everyday life

What this means for you: how long you wait for an answer (tokens per second, Q28), what each answer costs, and why cloud bills for AI are measured in GPU-hours. It is also why new laptops advertise "AI chips" (NPUs), which are small stadiums built into the machine.

A 70B model on a CPU server can take several seconds per word. The same model on one modern GPU produces dozens of words a second.

The surprise: a model's reply to you is mostly multiplication. A large model performs on the order of a few hundred billion multiplications for every word it writes.

Under the hood

Transformer training and inference are dominated by dense matrix multiplications and attention, which map directly onto tensor cores. Training has high arithmetic intensity and saturates compute; inference is often memory-bandwidth-bound, because the weights must be streamed from memory for every generated token, which is why quantisation, KV caching, batching and speculative decoding matter. Frameworks such as PyTorch and JAX dispatch to vendor kernels, and compilers (XLA, TensorRT, Triton) fuse operations. Multi-GPU scaling depends on collective communication over fast interconnects.

Remember it like this: AI is millions of easy sums that can all happen at once.

Quick check: why can all of a model's multiplications happen at the same time? (None of them depends on another finishing first.)

Related: Q17 CPUs and GPUs · Q19 GPUs, from games to AI · Q28 Tokens per second

19. GPUs were built for games. Why are they now used for AI, and how did that happen?

Because drawing a game scene and running a neural network are the same kind of job: millions of identical calculations at once. In 2012, researchers trained an image-recognition network on two gaming graphics cards and beat every competitor by a wide margin. From then on, the gamers' chip became the AI industry's engine.

The simplest picture

A snowplough company discovers its ploughs are perfect for clearing airport runways. Nobody redesigned the plough. Someone noticed the job was the same.

Gaming cards were built to colour millions of pixels at once. AI needs millions of sums at once. Same plough, new runway.

In everyday life

The timeline in plain words: 1999, the first chip called a GPU, for games. 2007, Nvidia opens the chip to general mathematics (CUDA). 2012, the AlexNet result: two gaming cards, one student, a landslide win in the world's main image-recognition contest. 2016 onward, purpose-built data-centre GPUs. 2022 to 2025, the AI boom turns Nvidia into one of the most valuable companies on earth.

For countries, this changed what an AI strategy means. Before a ministry plans models, it must plan compute: buy chips, rent them, or use a cloud, and under what rules. Export controls on advanced chips are now foreign policy.

The surprise: many of the founding results of modern AI were trained on cards bought from ordinary computer shops.

Under the hood

The enabling change was programmability. CUDA exposed the GPU as a general parallel processor; cuDNN (2014) provided optimised convolution and matrix primitives; frameworks (Caffe, Theano, TensorFlow, PyTorch) hid the details. Hardware then co-evolved with AI: tensor cores from the Volta generation (2017), high-bandwidth memory, NVLink, FP8 support and rack-scale systems. Gaming GPUs remain useful for local inference and small fine-tuning; data-centre parts differ in memory capacity (80 to 192 GB), interconnect bandwidth and reliability features.

Remember it like this: same chip, new job.

Quick check: what was the 2012 event that showed gaming cards could power AI? (AlexNet winning the ImageNet contest on two gaming GPUs.)

Related: Q17 CPUs and GPUs · Q18 Why AI runs well on GPUs · Q5 Why AI boomed in 2023

20. Are ChatGPT and Gemini just big RAG systems? If not, how are they different?

No. Their knowledge is stored inside the model's weights, learned during training. RAG (retrieval-augmented generation) is a separate technique that looks up documents at question time and hands them to the model. Modern chatbots do add web search or document lookup as a tool, but the core is a model that has already learned, not a search engine with a writer attached.

The simplest picture

Two doctors. The first spent ten years studying and answers from memory. The second answers by opening a reference book while you sit there.

ChatGPT and Gemini are the first doctor, who sometimes opens a book when you ask about today's news or your own files. RAG on its own is the second doctor.

In everyday life

A simple test. Switch off the chatbot's internet access and ask it a general knowledge question. It still answers. The knowledge was inside all along.

RAG is the right tool when the knowledge is yours or changes daily: your policy manuals, your case files, this morning's prices. The model writes; the retrieved documents keep it accurate and current, and it can cite them.

A UN agency builds an assistant over its own procedures. The model has never seen those manuals, so on its own it would guess. With RAG, every answer is drawn from the manual and points to the page.

The surprise: RAG can make a small, cheap model as useful as a giant one for your documents, because the knowledge comes from your files, not from the model.

Under the hood

The distinction is parametric knowledge (in the weights) versus non-parametric knowledge (retrieved at inference). A RAG pipeline chunks documents, embeds them (Q9), stores vectors in an index, retrieves the top matches for a query, assembles them into the prompt and generates an answer with citations. Variants: hybrid lexical-plus-dense retrieval, reranking, query rewriting, agentic retrieval and graph-based RAG. Consumer chatbots bolt on search and file tools that behave like RAG, and long context windows plus memory features complement it, but the base capability is parametric. The trade-off: freshness and provenance from retrieval; fluency and breadth from the weights.

Remember it like this: weights are memory; RAG is looking it up.

Quick check: a chatbot answers a history question with no internet. Where did the answer come from? (Its weights.)

Related: Q9 Embeddings · Q26 Embeddings in search and RAG · Q10 Weights

21. What are the baby steps if I want to build my own AI model?

You will not build a ChatGPT; nobody does that alone. But you can, in order: use AI tools daily, run an open model on your own computer, build a small assistant over your own documents, fine-tune a small open model on a narrow task, and train a tiny language model from scratch to understand the mechanics. Each step takes weeks, not years.

The simplest picture

You do not build a car factory to learn to drive. You start with a go-kart.

Step one is sitting in the seat: use the tools every day. Step two is a kit car: an open model running on your own laptop. Only much later, if ever, do you weld your own chassis. Age is not the barrier. Starting is.

In everyday life

The five steps, with the tools named:

1. Use ChatGPT, Claude or Gemini for real tasks every day. Keep a notebook of what worked and what did not. This builds judgement, which no course can.
2. Install Ollama or LM Studio and run an 8B model on your own computer, offline. It costs nothing, and from that day you own an AI model.
3. Build a document assistant over your own files (that is RAG, Q20), with a no-code tool or a few dozen lines of Python.
4. Fine-tune a small open model on one narrow task, such as sorting your emails by topic, using Hugging Face tools and a rented GPU (Google Colab).
5. Follow Andrej Karpathy's free "Let's build GPT" video and train a toy model from scratch. Afterwards, weights, tokens and inference are no longer mysterious.

A programme manager with no coding background can do steps one to three in a summer. Steps four and five need patience and some Python, but not a computer science degree.

The surprise: step two works without internet, on a laptop, for free.

Under the hood

Fundamentals: linear algebra basics, gradient descent, tokenisation, embeddings, attention. Tooling: Python, PyTorch, Hugging Face Transformers and PEFT, a vector store, an evaluation harness. Data: start small and clean; curation beats volume. Compute: a consumer GPU with 8 to 24 GB of memory or a rented notebook. The skills that actually add value for most individuals are data curation, evaluation, context engineering, deployment and monitoring, not training from scratch. Training a frontier model requires thousands of accelerators and a team; fine-tuning and retrieval are where a single person makes a difference.

Remember it like this: drive first, build later.

Quick check: what is the cheapest step that makes you "own" an AI model? (Running an open model on your own computer.)

Related: Q14 What 8B and 70B mean · Q20 Are chatbots just RAG? · Q24 AI engineering or AI governance?

22. Most training data is English. When I ask in Arabic or French, does the model use the English data, translate, or what?

The model does not translate first. All languages live in one shared network, so much of what it learned from English text carries over to Arabic or French automatically. But it read far less Arabic, so vocabulary, nuance and accuracy are thinner, and Arabic usually costs more tokens per word. That is why Arabic-focused models such as Jais, Fanar and ALLaM exist.

The simplest picture

A clerk who learned his profession in English and speaks Arabic at home. Ask him a question in Arabic and he does not translate in his head. The skill is one skill.

But the specialist words he only ever read in English come out clumsy in Arabic. The model is that clerk, and it has read a thousand English books for every Arabic one.

In everyday life

What you will notice: good Arabic on general topics; weaker on dialect, poetry, legal precision and local facts; the occasional sentence shaped like English; and slower, costlier answers, because Arabic words are chopped into more pieces (Q28).

How to help it: ask in the language you want the answer in, give it your own terminology, and test with native readers. A UN office choosing a model for Arabic communications gives thirty real paragraphs to three models and lets Arabic-speaking staff judge, not a global leaderboard.

The surprise: the model can answer correctly in Arabic about a fact it only ever read in English. Meaning is shared across languages inside the network (Q9), so knowledge leaks across the language border.

Under the hood

Multilingual language models learn a shared representation space; parallel and comparable text align concepts across languages, so the internal representation of "water" and "ماء" converge, and knowledge transfers without an explicit translation step. Some interpretability research suggests the intermediate representations of English-heavy models are English-biased, which is consistent with the "shaped like English" phrasing users notice. Tokenisation compounds the gap: vocabularies trained mostly on English split Arabic into more, shorter tokens, raising cost and shortening effective context. Remedies: balanced pre-training corpora, language-aware tokenisers, continued pre-training and instruction tuning in the target language (Jais, ALLaM, Fanar), and evaluation on Arabic-native benchmarks rather than translated English ones.

Remember it like this: one brain, many languages, unequal reading.

Quick check: does the model translate your Arabic question into English before answering? (No. It processes it directly in a shared network.)

Related: Q9 Embeddings · Q28 Tokens per second · Q7 Benchmarks

23. What is the difference between an AI agent and agentic AI?

An AI agent is a specific piece of software that can take actions toward a goal: search, open files, send emails, run code, check the result and try again. Agentic AI is the general approach of building systems that act with that kind of autonomy over many steps. Agent is the thing; agentic is the quality.

The simplest picture

A travel adviser and a travel agent. The adviser tells you which flight to take. The agent books it, notices it is full, books the next one and emails you the ticket.

A chatbot is the adviser. An AI agent is the agent. "Agentic" is the word for how much of the booking the system is trusted to do on its own.

In everyday life

Examples you will meet: a coding agent that fixes a bug and runs the tests; an assistant that reads your inbox and drafts replies; a research agent that searches, reads and compiles a report while you have lunch.

Why this matters more than chat: actions have consequences. A wrong sentence in a chat is a nuisance. A wrong email sent to a minister is an incident. So agents need permissions, logs, and a human approval step for anything that cannot be undone.

A procurement agent gathers quotes, checks them against the rules and drafts the comparison. A human signs. That division is the whole of agent governance in one sentence.

The surprise: most agents are the same chat model running in a loop. Think, act, look at the result, think again, until the job is done or a person says stop.

Under the hood

An agent is a language model plus tools (function calling), a control loop (plan, act, observe), and state or memory, often with sub-agents and an orchestrator; standard protocols now connect models to tools. "Agentic" describes a spectrum from a single tool call to long-horizon autonomy, characterised by autonomy level, planning depth and error recovery. Evaluation happens on task completion in realistic environments. Risks: compounding errors across steps, prompt injection through tool outputs and web content, and over-privileged credentials. Mitigations: least privilege, sandboxing, approval gates for irreversible actions, and full audit trails.

Remember it like this: an agent acts; agentic is the degree of acting.

Quick check: which one sends the email, the chatbot or the agent? (The agent.)

Related: Q20 Are chatbots just RAG? · Q24 AI engineering or AI governance? · Q28 Tokens per second When not to build an AI agent

24. Which field should I choose now: AI engineering or AI governance?

Choose by what you already bring. If you enjoy building and can learn to code, AI engineering has more jobs and clearer skills. If your strengths are institutions, policy, risk, procurement and people, AI governance is growing fast and needs people who understand how organisations actually work. The scarce profile is someone who can do one and speak the other's language.

The simplest picture

Building the bridge, or deciding where it goes and whether it is safe.

The engineer pours the concrete. The governance person writes the safety code, checks the load and decides who may cross. A country needs both. The rarest person is the engineer who can read the law, or the official who can read the blueprint.

In everyday life

Three questions to ask yourself. Do you enjoy making things work? Do you enjoy rules, risk and negotiation? Which of the two do you already have ten years of?

The engineering path: Python, the fundamentals of machine learning, building with model APIs, retrieval (Q20), agents (Q23), evaluation (Q8) and deployment. Judged by what you have built.

The governance path: risk frameworks (NIST AI RMF, ISO/IEC 42001), the EU AI Act and national equivalents, procurement and audit, data protection, evaluation literacy, and enough technical fluency to challenge a vendor's chart. Judged by decisions that held up.

If you are over fifty, governance usually lets you spend a career's worth of institutional judgement, and this page is the technical fluency it requires. Engineering is entirely possible at any age, but it demands daily practice, like a language.

The surprise: a large share of governance failures are technical illiteracy, and a large share of engineering failures are governance illiteracy. Whichever you choose, learn the other's vocabulary.

Under the hood

Engineering roles split into research, ML engineering (training, fine-tuning, evaluation), AI application engineering (LLM applications, agents, retrieval) and MLOps or infrastructure. Governance roles include AI risk and assurance, model evaluation and red-teaming, policy and standards, compliance and audit, and responsible-AI product management. Hybrid competencies in demand: writing and reading model cards, designing evaluations, monitoring and incident response, and mapping regulatory documentation requirements onto engineering artefacts. A practical strategy is to pair a technical portfolio with one governance artefact (a risk assessment or evaluation report), or the reverse.

Remember it like this: build it, or govern it; best of all, understand both.

Quick check: which profile is rarest? (Someone fluent in both.)

Related: Q21 Building your own model · Q8 Who decides which model is best? · Q23 Agents and agentic AI

25. Which programming language do OpenAI, Google, xAI (Grok) and Anthropic use to build their models?

Mostly Python for research and training code, with the heavy number-crunching written in C++ and CUDA underneath, through frameworks such as PyTorch (OpenAI, Meta) and JAX (Google, xAI). The model itself is not written in any language; it is a set of numbers produced by training. Companies do not publish every detail, so treat specifics as reported rather than certain.

The simplest picture

Asking what language a model is written in is like asking what language a photograph is written in.

The camera (the training code) was built with tools. The photograph (the model's weights) is what came out. The camera makers mostly use Python to aim and shoot, with fast C++ and CUDA machinery inside the lens.

In everyday life

What is publicly known: OpenAI standardised on PyTorch in 2020. Google uses JAX on its own TPU chips. xAI published the code for its first Grok model in JAX and Rust in 2024. Meta's Llama is PyTorch. Anthropic has not published a full breakdown of its stack.

Around the training code sits a great deal more: serving systems often written in Rust or Go, custom GPU kernels, and enormous data pipelines.

For you: if you want to work in this field, Python is the entry ticket. C++ and CUDA are for specialists who write the fast parts.

The surprise: a finished model contains no code at all, only numbers. The code is the factory; the model is the product.

Under the hood

Training stacks are PyTorch with FSDP, Megatron or DeepSpeed, or JAX with XLA on TPUs; performance-critical kernels are in CUDA or Triton. Inference engines (vLLM, TensorRT-LLM, SGLang) mix C++, Python and Rust; tokenisers are commonly Rust; data pipelines run on Python, Spark or Rust. Frontier labs maintain proprietary distributed-training frameworks, and their details are not public. Weight files (safetensors, GGUF) are language-agnostic and can be loaded by any runtime.

Remember it like this: Python drives the camera; the model is the photograph.

Quick check: is a trained model a program written in Python? (No. It is a set of numbers produced by training code, which is mostly Python.)

Related: Q10 Weights · Q21 Building your own model · Q17 CPUs and GPUs

26. How are embeddings used in search, chatbots and RAG?

Embeddings turn your question and every document into map coordinates (Q9). Search then means "find the documents whose coordinates are closest to the question", which finds meaning rather than matching words. Chatbots use this to pull the right passages from your files before answering (RAG), to group similar messages, and to recommend related items.

The simplest picture

The meaning-shelved library from Q9. You walk in with a question. The librarian works out its shelf address and brings you the five books shelved nearest to it, whatever their titles say. That is embedding search.

RAG is that librarian handing those five books to a writer who drafts your answer from them.

In everyday life

Where this earns its keep: office document search that understands synonyms and works across Arabic and English; customer support that finds the right answer from a badly spelled question; sorting thousands of survey responses into themes; "similar cases" in case management; the retrieval step of every document assistant.

Two practical warnings. Quality depends on how documents are chopped into pieces before they are shelved; chop badly and the librarian brings half a paragraph. And the embedding model must be good in your language; many are excellent in English and mediocre in Arabic.

The surprise: a good multilingual embedding model puts an English report and its Arabic translation at almost the same address, so one search finds both.

Under the hood

The pipeline: chunk, embed, index (HNSW or IVF), embed the query, approximate nearest-neighbour search for the top k, optional reranking with a cross-encoder, context assembly, generation. Hybrid retrieval (BM25 plus dense vectors) improves recall; metadata filters enforce permissions. Evaluate retrieval with recall@k and MRR, and the whole system on answer quality. Choose embedding models by language coverage and domain, weigh dimensionality against cost, and version the index, because changing the embedding model means re-embedding everything.

Remember it like this: address the question, fetch the nearest shelves, write from them.

Quick check: why does embedding search find a document that contains none of your words? (It compares meaning coordinates, not words.)

Related: Q9 Embeddings · Q20 Are chatbots just RAG? · Q22 Arabic and other languages

27. What is inference in AI?

Inference is the moment a trained model is used: you type a question, the model runs, an answer appears. Training is the years of study; inference is the exam sitting. Every inference costs computing power, which is why chatbots charge per token and why speed and cost per query matter as much as cleverness.

The simplest picture

A doctor's ten years of study happen once (training). Every patient visit afterwards is inference: quick, repeated thousands of times, and each one costs a little.

When you ask ChatGPT a question, you are the patient in the chair.

In everyday life

Why it matters to you: how long you wait, what each question costs (priced per million tokens), and where the work happens. Inference on the company's servers means your text leaves the building. Inference on your own laptop or server means it does not.

"Reasoning" models spend longer thinking during inference and cost more per question. That is a deliberate trade: more time on the visit, better diagnosis.

For an organisation, the bill is almost all inference. Training was done once by someone else; you pay for every visit. Using a smaller model for routine tasks is usually the biggest saving available.

The surprise: the model learns nothing from your question. Its weights are frozen (Q10). Every visit starts from the same doctor.

Under the hood

Inference is a forward pass with no gradient computation. For language models it is autoregressive: a prefill phase processes the prompt (compute-bound), then a decode phase generates one token per step (memory-bandwidth-bound, using a KV cache). Optimisations include quantisation, batching, paged attention, speculative decoding, distillation and prompt caching. Metrics: time to first token, tokens per second (Q28), throughput and cost per token. Deployment ranges from cloud APIs to self-hosted engines and on-device NPUs. Test-time compute scaling trades inference cost for accuracy.

Remember it like this: training is the study; inference is the visit.

Quick check: does the model update its knowledge when you ask it a question? (No. Inference uses frozen weights.)

Related: Q28 Tokens per second · Q13 How models are trained · Q18 Why AI runs well on GPUs

28. What does "tokens per second" mean?

A token is a piece of a word, roughly three-quarters of an English word; Arabic words often take two or three tokens each. Tokens per second is how fast the model produces its answer. Twenty tokens per second is about fifteen English words a second, faster than most people read, so anything above ten feels smooth.

The simplest picture

A typist's words per minute, counted in word-pieces instead of words.

A fast typist manages 80 words a minute. A model at 50 tokens per second is typing more than 2,000 words a minute. You are watching a typist who never pauses.

In everyday life

What to expect: cloud models, 30 to 150 or more tokens a second; an 8B model on a laptop, 10 to 40; a large model on an ordinary CPU, 1 to 3, which is painful. This is why long answers appear word by word: you are watching the typist.

Two other numbers matter. "Time to first token" is the pause before typing starts, and it is what makes a chat feel quick or sluggish. Input speed is how fast the model reads what you give it, and it is far higher than output speed.

Arabic and French cost more tokens for the same text, so the same model feels slower and the bill is higher. A twenty-page English report of ten thousand words is about 13,000 tokens; in Arabic it may be 30,000 or more.

The surprise: tokens are the unit of everything. Your bill, your speed and the limit on how much the model can read at once are all counted in tokens.

Under the hood

Tokenisation (BPE or SentencePiece) maps text to subword IDs; vocabulary size and language coverage determine tokens per word. Decode throughput depends on model size, precision, memory bandwidth, batch size and hardware; per-request tokens per second fall as batch size grows while total throughput rises. Prefill throughput far exceeds decode throughput. Context windows are measured in tokens. Reasoning models consume "thinking" tokens that count toward both latency and cost.

Remember it like this: tokens are word-pieces; tokens per second is typing speed.

Quick check: an answer arrives at 40 tokens per second. Roughly how many English words per second? (About 30.)

Related: Q27 Inference · Q22 Arabic and other languages · Q18 Why AI runs well on GPUs

Where to go next

This page is the plain-language layer. For definitions on their own, see the AI glossary. For structured lessons that build on these answers, the AI learning hub is free and needs no account.

To go deeper on particular questions: how LLMs work expands Q9, Q10 and Q26; running AI locally without a GPU expands Q14, Q18 and Q28; when not to build an AI agent expands Q23; and AI governance in the United Nations is the practical counterpart to Q24.

← All articles