The AI Stack, Explained

Every AI conversation in your company is running on borrowed vocabulary. Someone says "context window" and three people picture three different things; someone says "fine-tuning" and means prompting; the model "hallucinates" and half the room thinks that is a bug report instead of a design constraint. Fuzzy words produce expensive decisions. That is the problem NewStack.ai exists to fix - a plain-English encyclopedia of the AI stack - and its Core Concepts layer is the right place to start.

Vocabulary Is the Real Bottleneck

Teams do not stall on AI because the technology is unavailable. They stall because the people choosing models, budgets, and architectures are working from definitions they absorbed from headlines. The symptoms are everywhere:

• A vendor comparison that treats context window size as a quality score
• A budget built on "requests" when every API bill is denominated in tokens
• A roadmap that says "fine-tune the model" when the team means "write a better prompt"
• A stakeholder who believes hallucinations are a bug the next release will fix

None of those are technology failures. They are vocabulary failures, and they compound in every meeting where nobody wants to ask what a word actually means.

Start With the Words Everything Else Assumes

NewStack.ai's Core Concepts section covers 18 foundational entries with a blunt framing: "Every other layer of the stack assumes you know these words." The operational four come first:

• Token: the chunk of text - roughly three-quarters of a word - that a model reads and writes one at a time. Everything is priced in these.
• Context window: the total tokens a model can consider at once, input and output combined. Every RAG pipeline exists because this is finite.
• Inference: actually running the model. Training happens once; inference is what you pay for on every single request.
• Temperature: the dial between deterministic and creative output. Wrong setting, wrong product.

Four words, and suddenly API pricing, latency budgets, and "why did it give a different answer this time" all have explanations.

The Architecture Layer

Above the operational basics sit the words that describe what these systems actually are: LLM, the transformer architecture underneath it, mixture of experts (why frontier models can be huge and fast at once), multimodal AI (text, images, and audio in one model), and reasoning models that spend extra tokens thinking before answering. You do not need to implement any of them. You need to know them because model announcements are written in this vocabulary, and evaluating a release you cannot parse means outsourcing your judgment to the vendor's marketing team.

Training, Tuning, and Shrinking

The next cluster explains how models get their behavior - and their price tags:

• Fine-tuning: updating a model's weights on your data, versus just prompting it differently
• RLHF: the human-feedback training that made chat models actually useful
• Embeddings: text as coordinates, the trick underneath every semantic search and RAG system
• Quantization and distillation: the compression techniques that decide whether a model runs on a GPU cluster or a laptop

This is the vocabulary of cost decisions. When someone proposes fine-tuning, the counter-question - "did prompting fail first?" - only gets asked by people who know the difference.

The Prompt Layer

Two entries cover the layer most teams touch first: prompt engineering and the system prompt. Prompt engineering is shaping model behavior at request time - instructions, examples, structure - with no training involved and instant reversibility. The system prompt is the standing instruction set your application sends before the user ever types, which makes it product surface, not plumbing: tone, refusals, format, and guardrails all live there. These two concepts are where vocabulary most directly becomes money. Teams that understand them exhaust cheap, reversible prompt changes before reaching for fine-tuning; teams that do not skip straight to the expensive option because it sounds more like real engineering. The prompt layer is the highest-leverage, lowest-cost place to work, and knowing that requires knowing exactly what these words mean.

The Honest Entries

What separates a useful reference from a glossary of hype is how it handles the uncomfortable words. NewStack.ai defines hallucination as "when a model states false information fluently and confidently because it generates plausible text, not verified facts." Note what that definition does: it makes hallucination a structural property, not an occasional bug. That single sentence, actually understood, reshapes how a team designs review workflows, grounding, and evals. The open-weights entry does similar work for the build-vs-buy conversation - what you can and cannot do when the weights are downloadable.

A Reference Built Like a Stack

The concepts layer is deliberately not the whole site - it is the foundation the other layers stand on. As the encyclopedia puts it, the models category compares the systems these ideas describe, retrieval shows how embeddings and context windows get put to work on your data, and inference covers what it takes to run models in production. Beyond those sit agents and orchestration, evals and observability, AI coding, and safety and governance. Entries open with a two-sentence definition, carry review dates so you know they are current, and cross-reference each other - no vendor promotion, no hype, no unexplained jargon. In a field that reinvents its buzzwords quarterly, a maintained, neutral reference is infrastructure.

What Shared Vocabulary Looks Like in Practice

Picture the same vendor meeting twice. In the first, the pitch says "one-million-token context window" and heads nod, because bigger is presumably better. In the second, someone asks what the retrieval quality looks like at that length, someone else asks what those tokens cost per request at your volume, and a third person asks how much of the window your actual documents need. Same meeting, same pitch - completely different purchasing decision. The difference was not intelligence or seniority. It was that the second room shared precise definitions of three words and was therefore immune to the sales deck. That is the entire return on investment of a good reference: it converts vocabulary from a vulnerability into a filter.

Start Here

A practical way to put this to work with your team:

1. Read the 18 Core Concepts entries - it takes an evening, not a semester.
2. Adopt the definitions as team vocabulary: link the entry instead of re-explaining in every design doc.
3. Before the next vendor evaluation, make sure everyone in the room can define token, context window, inference, and hallucination without hedging.
4. When a new buzzword lands in a meeting, look it up before you budget for it.

The AI stack is not going to get simpler, but it is learnable - one precisely defined word at a time. Shared vocabulary is the cheapest AI investment you will ever make, and it pays out on every decision after it.