The 27 Most Important Words In AI Right Now

📖 Want the full visual edition with images and section design? View it on fourthweb.ai →

I run OpenClaw. I publish on the agent economy every week. I’ve built tools that touch real systems and ship real outputs.

And until I forced myself to map this out, I couldn’t define half these words cold.

That’s the gap.

Everyone uses these models every day. Almost nobody can name the parts. Tokens. Attention. RAG. RLHF. MCP. People throw the terms around like they’re settled vocabulary. Ask them what’s actually happening when ChatGPT predicts the next word, and the room goes quiet.

This isn’t a research paper. It isn’t a textbook. It’s the working vocabulary for The Fourth Web. Twenty-seven ideas. The language you need to operate, build, and not get rolled in conversations with people who actually know what’s under the hood.

Save this. Send it to the friend who’s still pretending.

One more thing before you scroll.

This isn’t a passive read. It’s a self-grade.

For each of the 27 concepts, ask yourself one question: could I define this cold to a smart friend, in plain English, without Googling?

Count the yeses as you go. The number at the end tells you exactly where you stand in The Fourth Web.

Don’t cheat. Don’t grade on a curve. This is the test that decides whether you build the next decade or watch it happen.

Tier 1: The Plumbing (how the math works)
Tier 2: How Models Talk (what’s happening when you prompt)
Tier 3: How Models Get Tuned (the post-training stack)
Tier 4: How Real Systems Get Built (the production layer)
Tier 5: The Agent Stack (where The Fourth Web lives)

If you only have ten minutes, skim Tier 1, then jump to Tier 5. That’s where the next decade is being built.

This is the part most people skip. They want to know what to type into ChatGPT. They don’t want to know how the math works. But the math is where the edge hides. The people who understand the plumbing build better systems on top of it.

A pipeline of math layers that learn patterns by adjusting billions of internal weights until the output matches what we want.

Picture a stack of filters. Data enters one side, passes through each filter, comes out the other side as a prediction. Each connection between filters has a number called a weight. The weight controls how much one filter’s output influences the next.

Training is just adjusting those weights, billions of times, until the network gets good at the task. That’s it. That’s the trick that powers everything from Netflix recommendations to Claude writing your emails.

The wild part is the scale. Frontier models have hundreds of billions of parameters, all running the same basic operation: signal in, weighted multiplication, signal out. No magic. Just math, repeated until intelligence falls out.

The model can’t read your text. It reads numbered chunks called tokens, which are often pieces of words, not whole ones.

When you type “investigating,” the tokenizer might split it into “invest” + “igat” + “ing.” When you type your name, it gets sliced into letters or letter-pairs the model has seen before.

Why not just use whole words? Because language is messy. New words appear daily. Slang. Typos. Names. A fixed word vocabulary would be impossibly large. Tokens are reusable building blocks. Roughly speaking, one token is about three quarters of a word.

This matters when you’re paying for API calls. Pricing is per token. Long prompts get expensive fast. When you upload a giant document and the model “forgets” half of it, the answer often starts here.

Every token gets converted into a list of numbers (a vector) that represents its meaning as a location in high-dimensional space.

Forget understanding. The model doesn’t “understand” words. It knows distance and direction. Words with similar meanings sit close together in this number space. Words with different meanings sit far apart.

The famous example: take the embedding for “Paris,” subtract “France,” add “Italy.” You land near “Rome.” The math captured the relationship between capitals and countries without anyone teaching it that concept.

This is what powers semantic search, recommendations, and the entire RAG stack we’ll get to in Tier 4. Every time a tool feels like it “understood what you meant,” embeddings did the work.

A mechanism that lets every word in a sentence look at every other word and figure out which ones matter for its meaning.

Take the sentence: “She stopped at the bank to deposit the check.” Is “bank” a riverbank or a financial institution? The word alone is ambiguous. Attention is the trick that lets the model use “deposit” and “check” to decide.

Before attention, models read left to right, one word at a time, and forgot most of what they’d just seen. After attention, models look at the whole sentence at once, weigh every word against every other word, and figure out what’s connected to what.

This single idea, introduced in a 2017 Google paper called Attention Is All You Need, unlocked everything we now call modern AI. If you only learn one of these concepts, learn this one.

The model architecture behind almost every language model worth using today. Stacked attention layers, processed in parallel, producing the next token.

The breakthrough was speed. Older models had to read text in order, one word at a time. Transformers read everything at once and let attention figure out the relationships. That parallelism is what made training on internet-scale data possible.

The architecture goes: text in, tokens, embeddings, dozens of stacked attention layers, output token. Each layer refines the model’s grip on what’s happening. Early layers catch grammar. Middle layers catch relationships between words. Deep layers catch reasoning, jokes, and metaphor.

Every major model is a transformer. GPT-5. Claude. Gemini. Llama. DeepSeek. One architecture, scaled to silly proportions. That’s the whole show.

Tier 1 check ↓ How many could you define cold? Keep counting.

You’ve got the plumbing. Now look at what’s happening when you actually open a chat window.

A transformer trained on a planet’s worth of text, optimized to predict the next token over and over until something that looks like intelligence emerges.

The training task sounds too simple to be useful. Show the model a chunk of text. Hide the next word. Make it guess. Score it. Adjust. Repeat trillions of times across books, websites, code, scientific papers, forum posts, and everything in between.

But scale changes everything. At small scale, you get a janky autocomplete. At trillion-parameter scale, you get a model that can write code, analyze contracts, translate poetry, and reason about problems it has never seen. No one programmed any of that. It fell out of next-token prediction.

That’s what people mean when they say “emergent.” Behavior that wasn’t in the training plan, but showed up anyway because the model got big enough.

The maximum amount of text the model can hold in working memory during a single conversation, measured in tokens.

This is the model’s RAM. Your prompt, plus its response, plus every back-and-forth in the conversation, plus any documents you attached, all have to fit inside this number.

The growth has been wild. Early GPT had a 4,000-token window. Claude Opus 4.7 runs a 1 million-token window at standard pricing as of March 2026. That’s roughly 750,000 words. War and Peace, twice over, with room to spare.

But there’s a trap. Models pay closer attention to the start and end of the context. The middle gets sleepy. It’s called the lost-in-the-middle problem, and it explains why a model can read a 200-page PDF and still miss something obvious from chapter four. Bigger window doesn’t mean perfect recall. It means more room to forget in the middle.

A dial that controls how random the model’s word picks are.

When the model generates each token, it doesn’t always pick the single most likely option. It rolls a weighted dice. Temperature is the dial that controls how wild the dice gets.

Low temperature (near zero): the model picks the safest, most predictable word every time. Good for code, math, structured data, anything where you want repeatable, boring, correct.

High temperature (1.0 and up): the model takes more chances. Good for brainstorming, fiction, creative angles. Bad for spreadsheets.

Most chat interfaces hide this dial from you. But knowing it exists explains why the same model on the same prompt sometimes feels like a careful accountant and other times like a tipsy poet.

The model generates something that sounds confident and is also completely false.

This isn’t a glitch. It’s the design. The model doesn’t search for truth. It predicts the most probable next token given everything before it. If a plausible-sounding fake fits the pattern, the model produces the fake with the same confidence it produces facts.

This is why you get fake legal citations. Fake quotes. APIs that don’t exist. Studies that were never written. The model is pattern-matching, not fact-checking.

There’s no fix at the model level. The fix is at the system level: ground the model in real data with RAG (Tier 4), or hand it tools that let it look things up (Tier 5). Trust nothing it produces about specific facts unless you can verify it. This is the single most important habit in working with these tools.

The craft of asking the model the right way to get the right output.

It’s not a hack. It’s communication. Same model, same question, dramatically different answers based on how you frame it. That’s not a bug. That’s how language works with humans too.

The moves that actually work:

• Give the model context about who you are and what you’re building.

• Assign it a role (”act as a senior backend engineer reviewing a PR”).

• Show examples of the format you want.

• Break complex tasks into ordered steps.

• Tell it what you don’t want, not just what you do.

Prompt engineering is starting to fall out of fashion as a job title because the models are getting better at handling vague requests. But the underlying skill (writing clearly, thinking before you ask) is the highest-impact skill you can build with these tools.

Tier 2 check ↓ Running total so far.

Out of the box, a base model is a brilliant but feral thing. It’s read everything. It has opinions about nothing. The work of turning it into something usable happens in post-training.

Take a model that already knows general patterns, then teach it your specific thing on top.

Training a base model from scratch costs hundreds of millions of dollars and takes months on the world’s biggest GPU clusters. Almost nobody does this. OpenAI. Anthropic. Google. Meta. DeepSeek. And a handful of others.

Everyone else starts with one of those base models and adapts it. The general knowledge is already there. You’re just bending it toward your use case. This is why a small medical startup can build a clinical assistant without first training a model on all of Wikipedia. They inherit Wikipedia for free.

The actual mechanism of transfer learning: keep training the model on your specific dataset until it gets good at your specific task.

Take a model that speaks general English, train it on 50,000 contract clauses, and now it speaks lawyer. Same model, narrower brain. The base capabilities are still there. The model just got opinionated about how contracts should sound.

Fine-tuning historically required serious compute. You had to update billions of parameters, which meant clusters of GPUs and infrastructure most teams couldn’t afford. That changed with LoRA and quantization, which we’ll get to.

The training step that teaches a model what humans actually want, not just what’s statistically likely.

After a base model finishes its trillion-token reading marathon, it’s still a feral autocomplete. It will happily generate offensive jokes, wrong answers, or thirty paragraphs when you wanted three sentences. RLHF is the part that domesticates it.

The process: show the model a prompt. Have it generate several responses. Have humans rank the responses from best to worst. Train the model to produce responses that score higher. Repeat thousands of times.

That’s why ChatGPT and Claude feel like assistants instead of unfiltered text generators. Without RLHF, they’d still be impressive. With it, they’re useful.

A training method developed by Anthropic where the model critiques and revises its own responses against a written set of principles, instead of relying entirely on human raters.

Standard RLHF needs an army of human labelers to score every response. That doesn’t scale, and the labelers bring their own biases. Anthropic’s answer was to write down a set of principles (a “constitution”) and have the model judge its own outputs against the document.

The original 2022 paper called it Constitutional AI: Harmlessness from AI Feedback. Anthropic published a major update in January 2026 describing Claude as something like “a brilliant friend who also has the knowledge of a doctor, lawyer, and financial advisor,” with hard constraints on things like weapons assistance.

This is the method behind the model writing the words you’re reading. It’s also one of the live debates in the field. Is the constitution the right text? Who gets to write it? Does training a model to critique itself create something more aligned, or just more confidently aligned with whoever wrote the document?

A fine-tuning shortcut that keeps the original model frozen and trains tiny adapter layers on top, cutting the cost by orders of magnitude.

The insight was that most fine-tuning changes are small. You don’t need to rewrite the whole brain. You need a small patch of new weights that nudges the model toward your task.

LoRA freezes the base model and trains those small adapters separately. Suddenly you can fine-tune a powerful open-source model on a single consumer GPU. You can keep one base model and swap different adapters in and out for different jobs. You can ship a stack of specialized models without the storage cost.

This is the technical reason the open-source model scene exploded. Before LoRA, fine-tuning was a billion-dollar company sport. After LoRA, it became a weekend project.

Compressing the model by storing each weight in lower precision, making it small enough to run on a laptop or a phone.

A weight stored in full precision uses 32 bits. Quantize it to 4 bits and the model is eight times smaller. The math is less precise. The model is dumber by a few percent. But it now runs on hardware you actually own.

This is why you can run a capable open-source model locally without a data center. LLaMA. Mistral. Qwen. DeepSeek. Quantized versions run on a MacBook, a gaming PC, or in lighter cases, a phone.

Without quantization, the frontier stays locked in data centers. With it, the frontier slides down toward your kitchen table.

Tier 3 check ↓ This is where the gap usually opens. Don’t lie about your score.

A raw model is a brain in a jar. It can talk. It can’t do anything. The production layer is where you wire it into real data and real workflows.

The pattern where the model looks something up in a database before answering, instead of guessing from training data.

Vanilla language models hallucinate because they’re answering from memory. RAG fixes that by giving them an open-book exam instead of a closed-book one.

The flow: user asks a question. System searches a knowledge base for the most relevant chunks. Those chunks get pasted into the model’s context. The model answers using the real material, not its hazy recollection from training.

Every serious AI product runs on RAG. Customer support assistants. Legal research tools. Internal company assistants. Wire.fourthweb.ai, the agent-powered news feed I built, runs on a RAG stack. The model isn’t smart because it knows everything. It’s smart because we taught it to look things up first.

The specialized database that makes RAG possible. It stores embeddings and searches by meaning instead of keywords.

Traditional keyword search needs exact word matches. Vector search needs only similar meaning. If you ask “how do I fire someone without getting sued,” a vector database finds the document about “lawful termination procedures” even though none of the keywords match.

How it works: every document gets converted into an embedding. Store the embeddings in the database. When a question comes in, convert that into an embedding too. Find the documents whose embeddings sit closest to the question’s embedding in vector space.

The big names: Pinecone, Weaviate, Qdrant, and pgvector (a Postgres extension). If you’re building anything that needs to search information by meaning, you’ll end up using one of these.

The prompting move where you ask the model to show its reasoning step by step before giving the final answer.

Models often get the wrong answer not because they can’t reason but because they answered too fast. If you ask “how many R’s are in the word strawberry,” a model can flub this. If you ask “count the letters one by one and show your work,” it usually nails it.

The trick is giving the model room to think out loud. Reasoning happens in the tokens themselves. More tokens spent on the problem means more compute applied to the problem. That’s why prompts like “think step by step” or “reason carefully through this” actually move scores.

This is also the foundation of the reasoning models we’ll hit in Tier 5. Extended thinking is just chain of thought, automated and turned into a feature.

The architecture behind almost every image and video generator. Instead of learning to draw, the model learns to remove noise from a noisy image, step by step.

This sounds backward, and it is. During training, the model is shown a real image. Noise gets added step by step until the image is pure static. The model’s job is to learn the reverse. Take noise, remove it step by step, recover the image.

At generation time, you start with pure noise. The model removes noise step by step, guided by your text prompt, until an image emerges. The name comes from physics. Particles diffusing through a medium, like ink spreading in water. The model is learning to reverse the spread.

This is how Midjourney, Stable Diffusion, Flux, and the video models like Kling, Seedance, and Veo all work under the hood. Same trick. Noise to image, guided by text.

A single model that handles multiple input types (text, image, audio, video) instead of needing separate specialized models for each.

Older systems chained things together. You used a vision model to describe an image, fed the text into a language model, and got a response. The new generation skips the middleman. The model itself reads pixels and reads tokens with the same brain.

The frontier has split by modality. Gemini 3 leads on video and audio understanding. Claude Opus 4.7 leads on long-document OCR. GPT-5.5 leads on charts and code-with-vision. The benchmarks that mattered in 2024 are now saturated. The new race is happening on the harder modalities.

What this means in practice: you can show a model a photo of a whiteboard and get back working code. You can hand it an hour of video and ask for the contradictions across speakers. The interface to a model isn’t a chat box anymore. It’s whatever you can capture.

Tier 4 check ↓ Almost there. The last six are where The Fourth Web actually lives.

This is where The Fourth Web actually lives. Models that don’t just respond. Models that take actions, hold memory, and operate in real systems on your behalf.

A model wrapped in a loop that lets it think, take an action, observe what happened, and decide what to do next.

The simplest way to put it: a language model answers. An agent does.

The agent loop looks like this: receive a goal. Plan. Pick a tool. Use the tool. Read the result. Decide if you’re done. If not, plan again. Repeat until the goal is met.

A coding agent fixing a bug: reads the issue, explores the codebase, finds the broken function, writes a patch, runs the tests, reads the failures, adjusts the patch, runs again, ships when green. The model is the brain. The tools are the hands. The loop is what turns a one-shot chat into actual work.

OpenClaw, the agent setup I run, is built on this exact loop. It still works. That’s not a small thing.

The mechanism that lets a model call external code, query APIs, run searches, and touch the real world.

A model on its own is locked inside its context window. It can talk about the weather. It can’t check the weather. Tool use is what bridges the gap.

The model is given a list of available tools and their interfaces. When it decides it needs one, it produces a structured call (something like get_weather(city='New York')). Your system catches the call, runs the actual code, and feeds the result back into the model’s context. The model continues the conversation with the new information.

Every modern agent runs on this primitive. Web search. Code execution. File system access. Database queries. Email and calendar. Anything you can wrap in a function, the model can call. This is the move that turns a chatbot into a worker.

An open standard, introduced by Anthropic in November 2024, that gives every model a universal way to plug into tools and data sources.

Before MCP, every model had its own format for tool use. Connecting Claude to your calendar was different from connecting GPT to your calendar. Each combination was a custom build. The industry called it the “N times M” problem. N models times M tools equals an integration nightmare.

MCP collapses that. One standard for the model side, one standard for the tool side, anyone can plug into anyone. Anthropic open-sourced it. Then everyone else adopted it. Block, Replit, Cursor, Zed, and a long list of others built MCP support. By the end of 2025, MCP had quietly become the way models talk to tools.

This is one of the most important developments of the last two years, and most people outside the developer world have no idea it exists. If tool use is the move that turned chatbots into workers, MCP is the move that lets every model and every tool actually work together.

The layer that gives a model persistent context across conversations, instead of starting from zero every time.

By default, every chat is a fresh slate. The model has no idea you talked yesterday. No idea what you’re working on. No idea what your preferences are. That’s fine for one-off questions. It’s terrible for anything that requires continuity.

Memory systems sit outside the model and feed relevant context back in. Some are simple (a list of facts about you, injected into the system prompt). Some are sophisticated (vector databases of past conversations, retrieved per query). The state of the art is moving fast.

Claude has memory features. So does ChatGPT. So does basically every serious assistant. The race is no longer about who has memory. It’s about who has good memory. Useful, controllable, and honest about what it remembers and what it forgets.

A class of model (or a mode within a model) that spends extra compute thinking before answering, producing visibly better results on hard problems.

OpenAI shipped this first with o1 in late 2024, then o3 and o4. Anthropic added extended thinking to Claude in early 2025. Google has its Deep Think mode in Gemini. DeepSeek shipped R1.

The mechanism is the same idea as chain of thought, but baked into training. The model is trained with reinforcement learning to spend tokens reasoning through a problem before producing the final answer. The reasoning happens in a separate phase, sometimes visible, sometimes hidden. The user sees the conclusion.

It’s not always better. Research shows extended thinking can hurt performance by up to 36% on certain task types, similar to how humans perform worse on simple tasks when they overthink them. Use it for math, code, complex planning. Skip it for writing, recall, and creative work.

By 2026, reasoning isn’t a separate model anymore. It’s baked into the flagship models. Claude Opus 4.7. GPT-5.5. Gemini 3. You don’t opt in. You get it by default, with a dial to control how hard the model thinks.

The capability that lets a model see your screen, move your cursor, click buttons, and operate software the way a human does.

Anthropic shipped this as a research preview in March 2026 for Claude Pro and Max subscribers, then strengthened it with the Vercept acquisition in February 2026. OpenAI’s Codex has similar capabilities. So does Perplexity. So does Meta’s Manus.

The mechanic: the model sees a screenshot of your screen, decides what to click, sends mouse and keyboard signals, and reads the next screenshot to see what happened. It’s a feedback loop that turns the screen itself into the interface.

This matters because most software will never have an MCP server or an API. There’s a long tail of internal tools, legacy apps, and weird workflows that a model can only touch by operating the screen. Computer use is the fallback that makes the rest of the agent stack actually useful in the real world.

It’s slow. It’s fragile. It’s still early. And it’s also the bridge between models that can talk and models that can work.

Tier 5 check ↓ Final tally below.

Remember the room that went quiet?

The one where someone dropped the words and nobody could define them?

Let’s revisit that list.

Tokens. ✓ Concept 02. Numbered chunks of text the model actually reads.

Attention. ✓ Concept 04. The mechanism that lets every word weigh every other word.

RAG. ✓ Concept 17. Open-book exam instead of closed-book guessing.

RLHF. ✓ Concept 13. The training step that domesticates a feral autocomplete.

MCP. ✓ Concept 24. The standard that lets every model talk to every tool.

Five words. Five concepts. Now the room is yours.

That’s twenty-seven concepts total. You probably knew some of them. You probably hadn’t heard of others. The point isn’t to have memorized all of them. The point is to have the map.

Most people use AI.

Operators name the parts.

That’s the gap. That’s the whole game.

Most people will stay on the using side. They’ll keep typing into chat boxes and getting whatever comes out. The operators (the people building inside The Fourth Web) will be on the other side of that gap, with the vocabulary and the systems-level view that lets them ship real things.

The Fourth Web framework is built on four moves: Read, Write, Own, Build. Tier 1 and Tier 2 give you the Read. Tier 3 and Tier 4 give you the Write. Tier 5 gives you the Build. Own is whatever you make with the rest.

Here’s what nobody’s writing about yet: when three agents disagree, who wins the tie? When an agent’s memory gets corrupted by an adversarial input, does it know? When the agent stack hits production, what actually breaks first?

That’s Volume 02. Coming soon. Don’t miss it.

Save this. Send it to someone who’s still pretending they understand all of this.

See you on the next move that matters.

Count your yeses. Be honest.

0 to 9: You’re a tourist. You use these tools. You don’t understand them. That’s fine. Most people will stay here forever. The good news: you just got a map. Start at Tier 1. Read it twice.

10 to 20: You’re a user. You know the surface. You can hold a conversation about most of this. You also know which words still make the room go quiet for you. Those are your homework. The Fourth Web is reachable from here.

21 to 26: You’re an operator. You can name the parts. You understand the stack. You’re already building, or you should be. Welcome. Keep going. Most of what’s interesting happens from here.

27: You’re in The Fourth Web. You don’t need me to explain any of this. You’re already shipping. Send this article to someone you want to bring with you.

Comment your score. I read every one. The honest scores are the ones I respect most.

Travis Wright is the world’s first Chief Web4 Officer. He builds at the intersection of AI, fintech, and the agent economy. Subscribe at aiagenteconomy.substack.com for the moves that matter, every week.