AI Literacy & Prompting Module 1 – How AI works, in plain words
Models, apps and AI features explained
Tell a model from the app built on it, read a model card for cutoff and limits, compare cloud, open-weight and on-device models, and date what you rely on.
What you will learn
- Distinguish a model, the app built on it and features such as web search, file upload and voice
- Read a model card to find its licence, context length, training cutoff, intended use and limitations
- Compare cloud, open-weight and on-device models on privacy, offline use, cost and quality
- Explain why model names change quickly, and record the app, model, version and date of an answer you rely on
Before you start
What you’ll learn · Before you start
What you will learn
- Distinguish a model, the app built on it and features such as web search, file upload and voice
- Read a model card to find its licence, context length, training cutoff, intended use and limitations
- Compare cloud, open-weight and on-device models on privacy, offline use, cost and quality
- Explain why model names change quickly, and record the app, model, version and date of an answer you rely on
Before you start
On this page
Three people ask “the AI” the same question and get three different answers: one in a phone assistant with web search switched on, one in a chat website without it, one in a study app whose hidden instructions forbid giving answers away. Each is right about what they saw, because each used a different app, and the app decides much of what the model: The part of an AI system that turns an input into an output. A learned model is a set of numbers worked out from its training data, such as word counts or the weights of a neural network. More in “What AI is and how it learns from examples” behind it reads.
You will separate the model from the app around it, see what each feature adds and how it fails, read a model card: A short document published with a model that states what it is for, how it was evaluated and where it fails, with details such as its version, licence, languages and training data. for what it promises and what it leaves out, choose where a model should run for a task of your own, and learn what to write down whenever you rely on an answer.
A model is the engine; the app decides what reaches it
When someone says “the AI said”, two layers spoke. The model is a set of learned numbers that predicts the next token. The app around it is everything else you meet: the screen you type in, the hidden instructions it adds, the chat history and notes it keeps, the tools it may call, and the filters and limits it applies. One model can sit behind many apps, and one app can switch the model behind it:
A model and the app built on it
Text description of the diagram
The diagram runs from top to bottom.
- You send a message to the app.
- The app holds what you see and type, its hidden instructions (the system prompt), chat history, saved notes and files, the tools it calls when they are switched on (web search, a file reader, speech to text) and its filters and limits.
- The app sends the model one long text made of all of this and your message.
- The model, a set of learned numbers that predict the next token, sends the reply back to the app token by token, and the app shows it to you.
Strengths and faults can come from either layer. A model that writes clearly can sit behind an app that silently cuts your file in half, and the best app cannot make a small model know what it never learned. So “the AI said” is not enough to judge an answer by, or to report one: the app, the model and the features that were switched on all belong with it.
Checkpoint
Check: A model and the app around it
Each feature adds a part outside the model
Most features are the app’s work, not the model’s: the app runs a tool and puts what it got back into the text the model reads. Each one adds its own way to go wrong:
| Feature | What the app adds | What can go wrong |
|---|---|---|
| Web search | Searches, then puts the text of the top pages into the model’s input | Old or wrong pages; an answer that misreads them; instructions hidden in a page |
| File upload | Pulls the text out of your file and adds it | Long files cut to fit; scanned pages with no text layer; private data leaves your device |
| Voice | Usually turns your speech into text before the model, and the reply into speech after | Misheard names, numbers and accents |
| Image input | A model that reads images, or text recognition | Small print and handwriting misread |
| Image generation | A model that makes pictures, often a separate one | Invented details; pictures of real people |
| Deep research | Many searches and a long report built from them | More sources to check, and errors that hide in a long report |
| Connectors | Access to your email, files or calendar | The app reads private data; instructions hidden in an email |
| Agents | Actions such as filling forms, booking or sending | Acting on a wrong answer, with your permissions |
OWASP’s top 10 risks for applications of language models name two of these failures. “Indirect prompt injections occur when an LLM accepts input from external sources, such as websites or files” (LLM01), which is why a web page or an email can try to steer the model. And an app that lets a model act can suffer “excessive agency”: “damaging actions” carried out because of an “unexpected, ambiguous or manipulated” output of the model (LLM06). Step through one question answered with web search switched on:
The drawing shows the whole scene; its 6 steps are listed below.
Every step as text
- A question. You ask when a museum opens on Sundays, with web search switched on in the app.
- The app searches. The app, not the model, runs a web search and fetches the text of the top pages. Which pages it picks decides what the model will read.
- One text again. It sends the model your question, the text of the three pages and an instruction to answer from them and cite them.
- Writing from the pages. The model writes an answer from the pages it was given, token by token, and adds their links. It cannot tell an old page from a current one unless the text says so.
- Answer and links. The answer comes back with links to two of the pages.
- Your part. You see a fluent answer with sources. Open them: a link can point to a page that says something else, and a page can hide instructions aimed at the model, a risk OWASP calls indirect prompt injection.
The search, the choice of pages and the links were the app’s work; the model wrote from whatever text it was given. The later modules on checking AI output and on agents take these features one at a time.
Checkpoint
Check: What each feature adds
A model card says what a model is for and where it fails
Models come with documents that describe them. Mitchell and others proposed
model cards, “short documents accompanying trained machine learning models that provide benchmarked evaluation in a
variety of conditions”, which also say “the context in which models are intended to be used”. Their sections start
with the model’s details, among them its date and version, and go on to intended use, evaluation, training data,
ethical considerations and caveats. On a model hub, says Hugging Face’s
documentation, the card is the README.md of the model’s repository:
Markdown text with metadata at the top, such as the licence: The terms under which something may be used, changed and shared. A model's licence says what you may do with its weights, and sometimes with what it produces., languages and datasets.
Here is the card of a fictional model, written for this lesson, with a program that reads it the way a careful user does:
Python · card/read_card.py
"""Reads a model card the way a careful user does: the facts in it, and the questions it leaves open.
README.md beside this program is the card of a fictional model. A model card is a Markdown file whose
first lines, between the --- marks, hold metadata such as the licence and languages; its sections say what
the model is for, where it fails and how it was tested. The program finds the facts a user needs before
relying on a model, then lists the questions a careful reader still has.
"""
from pathlib import Path
card = Path("README.md").read_text(encoding="utf-8")
_, metadata, body = card.split("---\n", 2)
sections = {}
for part in body.split("\n## ")[1:]:
heading, _, text = part.partition("\n")
sections[heading.strip()] = text.strip()
details = {}
for line in sections["Model details"].splitlines():
key, _, value = line.removeprefix("- ").partition(": ")
details[key] = value
print("Facts the card gives")
print(" licence (metadata):", next(l.split(": ")[1] for l in metadata.splitlines() if l.startswith("license")))
for key in ("Version", "Languages", "Context length", "Training data cutoff"):
print(f" {key.lower()}: {details[key]}")
print(" intended use:", sections["Intended use"].split(".")[0].replace("\n", " "))
print(" out of scope:")
for use in sections["Out-of-scope use"].split(";"):
print(" -", use.strip().replace("\n", " ").rstrip("."))
rows = [r for r in sections["Evaluation"].splitlines() if r.startswith("| ") and "%" in r]
print("\nEvaluation, English against Hindi")
for row in rows:
name, english, hindi = [c.strip() for c in row.strip("|").split("|")]
gap = int(english.rstrip(" %")) - int(hindi.rstrip(" %"))
print(f" {name}: {english} against {hindi}, {gap} points lower in Hindi")
open_questions = {
"Hinglish or other mixed-language text": "Hinglish" in card,
"how its energy use or carbon was measured": "energy" in card.lower(),
"who to contact about a problem": "contact" in card.lower(),
"the instructions an app adds when it runs this model": "system prompt" in card.lower(),
}
print("\nQuestions the card does not answer")
for question, answered in open_questions.items():
if not answered:
print(" -", question)Output
Facts the card gives
licence (metadata): apache-2.0
version: 1.1, which replaced version 1.0 after a fix to its Hindi training data
languages: English and Hindi
context length: 8,192 tokens
training data cutoff: 2025
intended use: Homework help and explanations for school students in English and Hindi, with a teacher or parent available to check the answers
out of scope:
- Medical, legal or financial advice
- decisions about people, such as grading or admissions
- questions about events after the training data cutoff
Evaluation, English against Hindi
School maths word problems (500 questions): 71 % against 58 %, 13 points lower in Hindi
Reading comprehension (300 questions): 80 % against 66 %, 14 points lower in Hindi
Questions the card does not answer
- Hinglish or other mixed-language text
- how its energy use or carbon was measured
- who to contact about a problem
- the instructions an app adds when it runs this model
Recorded with Python 3.14.8 on macOS 26 arm64. To run it yourself: mise exec python@3.14.8 -- python3 read_card.py
card/README.md
---
license: apache-2.0
language:
- en
- hi
pipeline_tag: text-generation
tags:
- education
- fictional-example
---
# Example Tutor 2B
This model card describes a fictional model, written for a lesson on reading model cards. No such model exists.
## Model details
- Model type: a language model with 2 billion parameters that writes text
- Version: 1.1, which replaced version 1.0 after a fix to its Hindi training data
- Languages: English and Hindi
- Licence: Apache-2.0
- Context length: 8,192 tokens
- Training data cutoff: 2025
## Intended use
Homework help and explanations for school students in English and Hindi, with a teacher or parent available to
check the answers.
## Out-of-scope use
Medical, legal or financial advice; decisions about people, such as grading or admissions; questions about events
after the training data cutoff.
## Limitations
- It makes factual mistakes, more often on rare topics.
- Its Hindi answers are less accurate than its English ones (see Evaluation).
- It can repeat stereotypes found in web text.
## Evaluation
| Test set | English | Hindi |
| --- | --- | --- |
| School maths word problems (500 questions) | 71 % | 58 % |
| Reading comprehension (300 questions) | 80 % | 66 % |
## Training data
Public web pages and openly licensed educational material, filtered for quality. No chats with users.The card answers the questions a user should ask first: an Apache-2.0 licence, a context length of 8,192 tokens, a training cutoff of 2025, homework help as its intended use, and decisions about people, such as grading, ruled out. Its evaluation is honest about a gap that matters: on both test sets its Hindi scores are 13 and 14 points below its English ones. The program then lists what the card does not say. Mixed-language text such as Hinglish is never tested, energy use is not reported, nobody is named for problems, and nothing describes the instructions an app adds, because a card describes the model, not the apps built on it.
Five things to find before you rely on a model
The licence, the languages it was tested in, its context length, its training cutoff and the uses it rules out. If the card does not say, treat the answer as unknown, not as yes.
Checkpoint
Check: Reading a model card
Cloud, open-weight and on-device models trade privacy for power
The same task can run in three very different places:
- A cloud AI app runs the model on its provider’s servers. Your text travels there, the largest models run there, and you need a connection for every request.
- An open-weight model: A model whose learned numbers, its weights, are published for anyone to download and run on their own hardware. Open weights alone do not make a model open source in the full sense. has its learned numbers published, so you can download them and run the model on your own computer. NTIA’s report on such models notes that they let users work “without sharing data with third parties”. Open weights are not automatically open source: the Open Source Initiative’s definition also asks for the training code and detailed information about the training data.
- An on-device model: A model small enough to run on a phone, a laptop or in a browser, so that the text it reads need not leave the device. It usually makes more mistakes than the largest cloud models. runs on your phone or in your browser; in a browser, WebGPU lets the page use the device’s graphics chip. After a one-time download it works offline, and what you type need not leave the device.
The price of running locally is quality. Kaplan and others found that a language model’s prediction error falls steadily as its size, its training data and its training compute grow, so a model small enough for a phone usually makes more mistakes than the largest models in the cloud. Which option fits depends on your task. Answer three questions about one of yours:
Answer the questions above: the table then marks what fits your case and says why the rest does not.
| Where it runs | Your text stays with you | Works without internet | Quality on hard tasks | Cost to you | Effort to set up |
|---|---|---|---|---|---|
| A cloud AI app What you use: a website or app on the provider's servers | Poor Your text goes to the provider's servers; its data terms decide what happens to it | Poor Needs a connection for every request | Good The largest models run here | Mixed No charge up to a limit, then a subscription or a price per token | Good Sign in and type |
| Open weights on your laptop What you use: a model file you downloaded, run by a program | Good Text stays on your computer once the model is downloaded | Good Runs offline after the download | Mixed Limited by your memory: mid-sized models, more mistakes than the largest | Mixed No fee per use, but it needs a capable computer and its power | Mixed Download a large model file and a program to run it |
| On-device in the browser What you use: a small model that runs in the page | Good Runs in your browser or on your phone; the text stays on the device | Good Works offline once its files are stored | Poor Small models only: more mistakes on hard questions | Good Nothing per use | Good Opens in the page after a one-time download |
How the answers decide
- “Does the text include personal or confidential information?” Yes, it names people or holds secrets: adds a caveat to A cloud AI app. The text leaves your device. Send it only if your organisation's rules and the provider's data terms allow it, or remove the personal details first.
- “Will you always have an internet connection when you need the model?” No, sometimes offline: rules out A cloud AI app. A cloud app needs a connection for every request.
- “Does the task need the strongest model, such as a long analysis or hard reasoning?” Yes, it is hard: rules out On-device in the browser and adds a caveat to Open weights on your laptop. Small models make more mistakes on hard tasks. A mid-sized model on a laptop may do; test it on your own task first.
In short: private text points to a model on your own device, or to a cloud app only where your rules and its data terms allow it; no connection rules the cloud out; and a hard task points away from the smallest models. Different tasks can point to different places, so you may well use more than one.
Checkpoint
Check: Cloud, open-weight and on-device
Model names change fast, so date what you rely on
A brand name is not a version. The same app can switch the model behind it, a model can be replaced by a new version under almost the same name, and old versions are retired. Model cards record this: Mitchell and others put the date and version at the top of every card, and Hugging Face’s metadata has a field that points a model to its newer version. An answer you saved is the answer of one model, in one app, on one day.
Reporting what "the AI" said
Wrong: “AI says the deadline is the 30th.” Right: “A chat app, with web search on, said the deadline is the 30th; the official notice it linked confirms it.” The first cannot be checked or repeated; the second can.
So when an answer matters, write down enough for someone else, or you a month later, to check or repeat it:
| What to record | Why |
|---|---|
| The app, and the features switched on (search, files, a mode) | They changed what the model read |
| The model’s name and version, where the app shows them | The same app can switch models |
| The date | Models, apps and the facts themselves change |
| Your prompt and any files | So that the question can be asked again |
| The sources it cited, opened and checked | So that the claim can be checked without the AI |
Key idea
Record the app, the model and its version, the features you used and the date of any answer you rely on: without them nobody, you included, can check or repeat it.
Checkpoint
Check: Versions, dates and records
Practise: read a card, pick a place, write a note
Three checks that bring the lesson together, then the self-check:
Checkpoint
Read, choose and record
Below, the self-check asks first about the idea your answers so far show you know least well:
Practice that adapts to you
Practise this lesson
10 questions about 5 ideas of this lesson. Each answer is explained at once, and what you get right is kept in this browser.
Interview questions
Warm-up (fresher to mid-level): How does a model differ from the app built on it?
The model is the trained part: a set of learned numbers that takes text in and predicts the next token, over and over. The app is everything around it that a user meets: the screen, the hidden instructions it sends with every message, the chat history and saved notes it keeps, the tools it can call, such as web search or a file reader, and its filters and limits. One model can power many apps that behave very differently, and one app can switch the model behind it without changing its name. When an answer is wrong, the cause can sit in either layer: the model may not know the fact, or the app may have cut the file, skipped the search or added instructions that steered the reply. That is why a good report of an answer names the app, the model and the features that were on.
Two scenario questions draw on the choices of this lesson:
Model answers open with any pass: ₹79 for 1 week ($2.99), one payment that never renews.
-
Mid to senior
Your manager asks you to choose between a cloud AI app, an open-weight model on a laptop and an on-device model for summarising confidential HR files. How do you decide, and what do you check in each option's documentation?
-
Fresher to mid
A colleague's report says "the AI said our competitor's prices rose 12 %". What is missing for anyone to check or repeat that claim, and how would you have the team record findings from AI tools in future?
Key takeaways
- A model is a set of learned numbers that predicts the next token; the app around it adds the screen, hidden instructions, memory, tools, filters and limits, and decides much of what the model reads.
- Most features are the app’s work, such as searching the web or reading a file, and each adds its own failure, from old pages to instructions hidden in a page or an email.
- A model card states a model’s licence, languages, context length, training cutoff, intended uses and evaluations; read what it leaves out as well as what it says.
- Cloud apps give the strongest models but take your text away; open-weight and on-device models keep it with you, usually at a cost in quality.
- Brand names are not versions: record the app, the model and version, the features and the date of any answer you rely on.
Terms in this lesson
- licence
- The terms under which something may be used, changed and shared. A model's licence says what you may do with its weights, and sometimes with what it produces.
- model card
- A short document published with a model that states what it is for, how it was evaluated and where it fails, with details such as its version, licence, languages and training data.
- on-device model
- A model small enough to run on a phone, a laptop or in a browser, so that the text it reads need not leave the device. It usually makes more mistakes than the largest cloud models.
- open-weight model
- A model whose learned numbers, its weights, are published for anyone to download and run on their own hardware. Open weights alone do not make a model open source in the full sense.
References
- Model Cards for Model Reporting (ACM (FAT* 2019, Mitchell and others))
- Model Cards (Hugging Face Hub documentation) (Hugging Face)
- The Open Source AI Definition 1.0 (Open Source Initiative)
- Dual-Use Foundation Models with Widely Available Model Weights (National Telecommunications and Information Administration)
- Scaling Laws for Neural Language Models (arXiv (Kaplan and others))
- WebGPU (W3C)
- LLM01:2025 Prompt Injection (OWASP Gen AI Security Project)
- LLM06:2025 Excessive Agency (OWASP Gen AI Security Project)
Related tools
Report a problem with this lesson
Kept only in this browser. Your Learn progress