Most AI coverage is written by people who forgot what it felt like not to know this vocabulary. The result is a wall of terms that sounds technical on purpose — as if understanding the jargon is a prerequisite for using the tools. It is not.
If you read the Pixel 10 Pro XL post and found yourself nodding along until a phrase like “128K context window” or “4-bit quantized GGUF weights” stopped you cold, this post is for you. Every term that matters for offline emergency AI, explained in plain language, with a real-world analogy attached to each one.
The Basics: What an AI Model Actually Is
Large Language Model (LLM)
An LLM is a software program trained to read text and produce useful text in response. That is the entire concept. “Large” refers to how much text it was trained on and how many internal connections it built during that training. “Language model” means it works with words, sentences, and documents — not images, not spreadsheets, not video (though newer models are adding those).
When you type a question into an AI and get a coherent answer back, you are using a language model. The “large” part is what separates a useful tool from a toy.
Why it matters for emergency preparedness: An LLM loaded with your town’s SOPs, roster, and protocols is a search engine for your own documents — one that understands plain-language questions instead of requiring exact keyword matches.
Model Weights
The “weights” are the actual knowledge stored inside an AI model. Think of them as the accumulated result of all the training — billions of tiny numerical settings that have been tuned, over weeks of computation, to make the model respond usefully to prompts.
When you download a model to your phone, you are downloading the weights. They are large files — typically 2 to 10 gigabytes — because there are a lot of them. Once they are on your device, the model can run without ever contacting the internet. The weights do not expire, do not change unless you choose to update them, and cannot be remotely revoked.
The analogy: Model weights are like the sum of a person’s education and experience. You cannot download a doctor’s medical knowledge from the internet in real time. But if the doctor is in the room with you, their knowledge is available immediately. Downloading model weights puts the “doctor” on the device permanently.
Open-Weight Models
An open-weight model is one where the weights are publicly released — meaning anyone can download, inspect, and run them. The Apache 2.0 license attached to Gemma 4 means you can use the weights for free, including in emergency response operations, without paying fees or accepting usage restrictions.
The opposite is a closed model: one where the weights live on a company’s server and you access them only through an internet connection. You never hold the knowledge. You are renting access to it.
The ownership test: If you can put your phone in airplane mode and the AI still works, you own it. If airplane mode breaks the AI, you are renting it.
How Models Think: Tokens and Context
Tokens
A token is the basic unit an AI model uses to read and write text. It is not exactly a word and not exactly a syllable — it lands somewhere in between. As a working approximation: one token is roughly three-quarters of a word. A typical paragraph of English text contains 75 to 100 tokens.
Models do not read letters or words directly. They convert everything — your question, your documents, their response — into tokens first, process those tokens, and convert the output back into readable text. This is invisible to you as a user. It matters only when you start counting how much the model can handle at once.
The analogy: Tokens are like the unit of measurement a chef uses when reading a recipe. You think in cups and tablespoons. The kitchen scale thinks in grams. The conversion is automatic. You never think about grams while cooking — until the scale runs out of range.
Context Window
The context window is the total number of tokens an AI model can hold in its “working memory” at one time. It is the size of the desk the model is allowed to work on. Everything you want the model to know — your question, your uploaded documents, the conversation so far — has to fit on that desk simultaneously.
When a document does not fit in the context window, the model cannot read it. When the context fills up during a long session, older parts of the conversation fall off the desk and are forgotten.
Gemma 4 E4B’s context window is 128,000 tokens — approximately 96,000 words, or roughly the length of a full novel. Gemini Nano’s context window is a few thousand tokens. The practical difference: Gemma 4 can hold your entire emergency document library in one session. Gemini Nano cannot hold a single lengthy SOP document.
The analogy: Think of the context window as the size of a whiteboard in your operations center. A small whiteboard forces you to erase old information to write new information. A large whiteboard lets you keep the entire situation visible at once. When you are coordinating a shelter operation, you want the large whiteboard.
Parameters (The Numbers in Model Names)
When you see “Gemma 4 E4B” or “Llama 3.2 3B,” the number followed by “B” indicates billions of parameters. A parameter is one of the numerical settings inside the model — a single dial in a system with billions of dials. More parameters generally means a more capable model, because the model has more internal complexity available to represent knowledge and reason through problems.
The “E” in Gemma’s E4B stands for “effective” — a technical efficiency technique that makes the model behave more capably than a raw parameter count would suggest.
The practical guidance: For emergency preparedness on a phone, a 4B (4 billion parameter) model is your everyday workhorse. A 12B model does better reasoning on complex multi-step problems but requires more RAM and runs somewhat slower. Anything above 12B does not currently fit on a smartphone at practical speeds.
How Models Run: Inference and Hardware
Inference
Inference is the act of running the model — giving it a prompt and having it generate a response. “Training” is what happened when the model was built (months of computation on server farms). “Inference” is what happens every time you ask it a question (seconds of computation on your device).
Every query you make is one inference. The speed of inference — how many tokens per second the model generates — determines whether the AI feels responsive or frustratingly slow. On a Pixel 10 Pro XL running Gemma 4 E4B, inference runs at speeds that feel like a fast typist. On older hardware, it can feel like watching someone type one letter per second.
Why inference quotas are a problem: Gemini Nano’s AICore system limits how many inferences your app can run in a given time period. Hit the ceiling and the app returns an error instead of an answer. There is no quota on Gemma 4 running through PocketPal AI or LM Studio — you own the compute, you run it as often as you need.
NPU and TPU (Neural Processing Unit / Tensor Processing Unit)
A standard computer processor (CPU) is designed to do many kinds of tasks reasonably well. An NPU or TPU is a specialized processor designed to do one kind of task extremely well: the specific type of matrix math that AI models use during inference.
The Pixel 10 Pro XL’s Tensor G5 chip includes a TPU that handles AI inference directly, without burdening the main processor. The result is faster responses and lower battery drain compared to running the model on the CPU alone. The 60% improvement over the previous generation means a real, noticeable difference in how quickly the model responds during a sustained emergency session.
The analogy: A CPU is a general-purpose workshop with every tool available. A TPU is a dedicated assembly line optimized for one product. If that one product is what you are making all day, the assembly line is much faster.
RAM (Random Access Memory)
RAM is the working memory a computer uses for tasks it is actively performing. It is different from storage (where files live permanently). When you run a model, the entire set of model weights needs to be loaded into RAM so the processor can access them quickly. If there is not enough RAM, the model either cannot load at all or loads partially and runs at unusable speed.
The Pixel 10 Pro XL’s 16GB of RAM is what makes running Gemma 4 12B possible on a phone. The iPhone 17 Pro Max has 12GB. That 4GB difference is the reason Gemma 4 12B — the model with the reasoning capability needed for complex emergency planning tasks — runs on the Pixel and does not run on the iPhone.
The analogy: RAM is the size of your desk. Storage is your filing cabinet. To work on a document, you take it out of the cabinet and put it on the desk. If the document is too large for the desk, you cannot open it all at once. The Pixel’s desk is large enough. Some competing desks are not.
Model Formats and Efficiency
Quantization (and What “4-bit” Means)
AI models are, at their core, enormous tables of numbers. By default, each number is stored at high precision — using 32 or 16 bits per value. Quantization is the process of reducing that precision, storing each number using fewer bits, to make the model smaller and faster without losing much capability.
A “4-bit quantized” model stores each value using 4 bits instead of 16 or 32. The model becomes roughly four times smaller on disk and in RAM, runs noticeably faster, and loses a small but acceptable amount of accuracy. For emergency use cases — protocol lookup, document retrieval, roster queries — the accuracy loss is not meaningful. For frontier research tasks, it might be.
The practical implication: When the model table earlier in this series lists “Gemma 4 E4B (4-bit)” at 3.3GB, that is the quantized version. The unquantized version would be approximately 10GB. Quantization is what makes capable models fit on a phone.
GGUF Format
GGUF is a file format for storing quantized AI model weights. It is the format used by llama.cpp — the open-source inference engine that underlies PocketPal AI, LM Studio, and most other on-device AI apps for Android. When you download a model from Hugging Face or LM Studio’s library, the file you download is typically a .gguf file.
You do not need to understand the format in depth. You need to know one thing: when an app says it supports “GGUF models,” it can run the open-weight models this series recommends. When an app does not mention GGUF, check before committing to it.
How You Talk to the Model
Prompt
A prompt is anything you type to the AI. Your question, your instructions, your documents — all of it together is the prompt. The model reads the entire prompt and generates a response.
Prompting well is a learnable skill. Clear, specific prompts get better responses. Vague prompts get vague responses. For emergency preparedness, the best prompts name the document they want the model to reference, name the specific question they need answered, and specify the format they want the answer in.
Good prompt: “From the attached Skills Census roster, list all block captains in Zone 4 who have indicated vehicle availability and have not yet been assigned a welfare check route today.”
Weak prompt: “Who can help in Zone 4?”
The difference in output quality is not subtle.
System Prompt
A system prompt is a set of standing instructions given to the model before any conversation begins. It defines the model’s role, its scope, and any rules it should follow. For emergency preparedness, a system prompt might read: “You are the emergency operations assistant for [town name]. You have access to our SOPs, Skills Census, and volunteer roster. Answer all questions based only on these documents. Do not speculate. Flag any question that falls outside your loaded documents.”
Setting a clear system prompt before an emergency means every operator who picks up the device gets a consistent, role-appropriate AI — not a general-purpose chatbot that might wander off-topic.
Function Calling and Agents
Function calling is the ability for an AI model to invoke a defined tool — a file lookup, a calculation, a formatted output template — as part of answering a question. Instead of just generating text, the model can take action: query your roster file, pull a specific SOP section, fill in an IOU ledger template.
An “agent” is a model configured with multiple tools and the ability to chain them together to complete multi-step tasks. Given a complex goal — “Assign the next shelter intake shift based on availability in the roster and flag any residents on the medical-priority list who have not been checked in” — an agent can complete the task without you manually prompting each individual step.
Gemma 4 supports native function calling. Gemini Nano has limited support. This is one of the defining capability differences between the two products for agentic emergency workflows.
The analogy: A model without function calling is a knowledgeable advisor who can only talk. A model with function calling is a knowledgeable advisor who can also open files, fill out forms, and cross-reference databases on your behalf.
The Ownership Layer
On-Device vs. Cloud AI
On-device AI runs entirely on your phone’s hardware. The model weights are stored on the device, inference happens on the device’s processor, and no data leaves the device during a query. It works without internet. It works in airplane mode. It works when every cell tower in a fifty-mile radius is down.
Cloud AI sends your prompt to a remote server, processes it there, and returns the response over the internet. It is faster on demand, more capable at frontier tasks, and requires zero storage on your device. It also requires an active, reliable internet connection for every single query.
For routine use, cloud AI is often the better choice. For emergency preparedness, it is not a choice at all — it is an assumption of a condition (working internet) that emergencies specifically destroy.
Open-Weight vs. Proprietary
Open-weight means the model files are publicly released and anyone can download, run, and modify them. Gemma 4 is open-weight under Apache 2.0. Llama 3.2 is open-weight under Meta’s license. You can put these on a device and run them indefinitely without paying anyone or asking permission.
Proprietary means the weights are kept private. You access the model through an API that the company controls, prices, and can revoke. GPT-4, Gemini, and Claude are proprietary cloud models. Gemini Nano is technically on-device, but the weights are managed and updated by Google — you do not hold them and cannot lock them to a known version.
The emergency infrastructure test: If the company behind your AI model shuts down, changes its terms of service, or pushes an update that breaks your workflow, does your emergency system still function? With open-weight models: yes. With proprietary and managed models: no.
The Bottom Line
AI terminology is not gatekeeping. It is vocabulary that describes real physical and operational constraints — how much text a model can hold, how fast it processes, whether you own the files it runs on. Every term in this glossary connects directly to a decision your community will make when setting up an offline emergency AI system.
The decisions that matter most: use a model with a context window large enough to hold your documents (128K, not 4K); use a model whose weights you own and can lock to a known version (Gemma 4 under Apache 2.0, not Gemini Nano under Google’s ToS); run inference on hardware with enough RAM to load the model without degradation (16GB); and write system prompts and prompts specific enough that any volunteer can operate the system consistently under stress.
None of this requires a computer science degree. It requires the same discipline your town brings to any other infrastructure decision: know what you are buying, know what you own, and know what happens when the vendor is unavailable.
Action Steps
| Citizens | Municipal Leaders |
|---|---|
| Print this glossary and keep it with your emergency AI kit. When a term in a setup guide stops you, look here first. | Include this glossary as an appendix in your municipal emergency AI standard operating procedure so every operator — including volunteers — can reference it. |
| Practice writing specific prompts against your loaded documents before the emergency. Vague prompts during a crisis waste time you do not have. | Require that your emergency AI system prompt be documented, version-controlled, and stored in your /emergency/SOPs/ folder alongside the device it runs on. |
| Confirm your Gemma 4 model file is the 4-bit quantized GGUF version — it will have “Q4” or “q4” in the filename. This is the version that fits on a phone and runs at practical speeds. | Test your emergency AI device quarterly with the context window near capacity — load all documents simultaneously and verify the model is still responding accurately before assuming it will perform under load. |
| Understand one thing above all others: if the AI stops working when you put the phone in airplane mode, it is cloud AI and it will fail during a grid-down event. Test this before you need it. | Establish a simple acceptance test for every new emergency AI device deployed: airplane mode on, full document library loaded, three representative prompts answered correctly. If it passes, it is ready. If it does not, it is not. |
| Ask your block captain network to read this glossary before the next preparedness drill. Shared vocabulary means faster problem-solving when things go wrong. | When writing grant applications for offline AI infrastructure, use the term “on-premises open-weight LLM” rather than generic “AI” — it is more specific, more credible, and maps directly to FEMA program language for critical communications infrastructure. |