AI, translated to human

A general-purpose AI helper — answering questions, drafting text, summarizing, planning. The word "assistant" increasingly implies it can also take actions for you, which is where assistants shade into agents.

A recipe a computer follows to solve a problem — a defined series of steps. In AI conversations it often gets used loosely to mean "the system deciding things," as in "the algorithm" behind your social feed.

An API, or application programming interface, is a set of rules and protocols that allows different software programs to communicate and exchange information with each other. It acts as a kind of intermediary, enabling different programs to interact and work together, even if they are not built using the same programming languages or technologies. API's provide a way for different software programs to talk to each other and share data, helping to create a more interconnected and seamless user experience.

Software that performs tasks we used to think required a human brain — understanding language, recognizing images, making decisions, writing, coding. Modern AI isn't programmed with rules for every situation; it learns patterns from enormous amounts of data. When people say "AI" today they usually mean generative AI: systems like ChatGPT or Claude that can produce new text, images, audio, and video on request.

Systematic skew in what an AI produces, usually inherited from its training data — a hiring model trained on past hires can replicate past discrimination. One of the most important practical problems in deployed AI, and why 'the data was biased' appears in so many AI news stories.

Software you talk to in conversation. Today's chatbots are usually a friendly interface wrapped around a large language model — the chatbot is the counter service, the LLM is the kitchen.

Sorting things into categories — spam or not, cat or dog, positive or negative review. One of the oldest and most common jobs given to machine learning.

Letting an algorithm group similar things together without being told the groups in advance — like sorting customers into natural segments by behavior. A classic example of unsupervised learning.

How well a model handles things it never saw during training. Good generalization is the whole point — a model that only performs on its training data is a very expensive parrot (see Overfitting).

AI that creates new content — text, images, music, video, code — rather than just analyzing what exists. The technology behind ChatGPT, Midjourney, and everything this site covers; when a headline says "AI" in 2026, it almost always means this.

The approach behind almost all modern AI: instead of writing step-by-step instructions, you show a computer millions of examples and let it figure out the patterns itself. Spam filters learned what spam looks like from examples of spam; today's chatbots learned language the same way, just at vastly bigger scale. If AI is the destination, machine learning is the vehicle that gets there.

The trained "brain" itself — the file full of learned numbers that turns inputs into outputs. ChatGPT is an app; GPT is the model inside it. When people compare "models," they mean these engines, not the apps wrapped around them.

The field of AI focused on getting computers to understand and produce human language — the technology behind chatbots, translation, voice assistants, and text summarization. For decades NLP was slow, rule-based work; large language models absorbed nearly the entire field almost overnight, which is why the term now mostly appears in academic and enterprise contexts.

A model's output, in traditional machine-learning language — the estimated answer, whether that's tomorrow's demand, a spam-or-not verdict, or the next word in a sentence. Modern chatbots are, at their core, extremely good next-word prediction machines.

Predicting a number rather than a category — tomorrow's temperature, a house price, next quarter's sales. The other classic machine-learning job alongside classification.

The process of creating a model: showing it enormous amounts of data while it gradually adjusts its internal settings until its outputs get good. Training happens once (and costs a fortune); using the result is called inference.

The mechanism that lets a model weigh which parts of the input matter for each part of the output — when generating the word after "the capital of France is," attention focuses on "France." The breakthrough that made transformers (and modern AI) work; the famous paper was literally titled "Attention Is All You Need."

A model fresh out of pretraining, before it's taught to be a helpful assistant — it completes text but doesn't follow instructions well and has no manners. Chat models are base models plus instruction tuning and alignment training.

A standardized test used to compare AI models — math problems, coding challenges, reasoning puzzles — producing the scores you see in every model announcement. Useful but gameable: models can be tuned to ace benchmarks while feeling no better in daily use, which is why "benchmarks aren't everything" is a running theme in AI news.

The best-known public leaderboard where anonymous models battle head-to-head and humans vote on the better answer, producing Elo-style rankings. Watched obsessively because it measures what people actually prefer, not just test scores.

The classic architecture for image recognition — it scans pictures in small patches, learning edges, then shapes, then objects. Powered the 2012 deep-learning breakthrough; still everywhere in computer vision even as transformers take over elsewhere.

Machine learning using neural networks with many layers stacked on top of each other ("deep" refers to the layer count). Each layer learns increasingly abstract patterns — edges become shapes, shapes become faces. The 2012-era discovery that depth plus data plus GPUs works astonishingly well is the direct ancestor of everything in AI today, from image generators to chatbots.

A huge general-purpose model trained on broad data that other products get built on top of — the 'foundation' under thousands of apps. GPT, Claude, Gemini, and Llama are foundation models; most AI tools you use are thinner layers on one of them.

A model at the leading edge of capability — the best anyone has shipped. "Frontier lab" means the handful of companies (OpenAI, Anthropic, Google DeepMind, Meta, and a few others) building them.

A type of computer program that creates new things, such as images or music, by training two neural networks against each other. One network, called the generator, creates new data, while the other network, called the discriminator, checks the authenticity of the data. The generator learns to improve its data generation through feedback from the discriminator, which becomes better at identifying fake data. This back and forth process continues until the generator is able to create data that is almost impossible for the discriminator to tell apart from real data. GANs can be used for a variety of applications, including creating realistic images, videos, and music, removing noise from pictures and videos, and creating new styles of art.

The model family behind ChatGPT, and the acronym that named an era. Each word matters: Generative (it creates new text rather than just classifying), Pre-trained (it learned general language skills from a huge dataset before being adapted for specific jobs), Transformer (the neural-network architecture that made it all work). OpenAI's naming stuck so hard that "GPT" became shorthand for this whole class of AI.

The moment an AI model is actually used — you ask, it answers. Training is when a model learns; inference is when it works. When you hear about the "cost of inference," that's the computing bill for serving all those answers, which is why companies obsess over making it cheaper.

A model given extra training on examples of instructions and good responses, so "write me a haiku about soup" produces a haiku instead of a rambling continuation. Essentially every chatbot you use is instruction-tuned.

A speed trick where the model saves its work on the conversation so far instead of re-reading everything for every new word it generates. It's a big reason long chats stay responsive — and a big consumer of GPU memory.

The engine inside ChatGPT, Claude, Gemini and similar tools — a giant neural network trained on massive amounts of text until it becomes remarkably good at predicting what words should come next. That simple-sounding skill turns out to unlock writing, summarizing, translating, coding, and reasoning. "Large" is literal: the biggest models have hundreds of billions of internal settings and cost hundreds of millions of dollars to train.

The internal "map of meaning" inside a model, where concepts live as positions — similar things sit near each other, and moving through the space morphs one concept toward another. Image generators literally navigate this space to turn your prompt into a picture.

An architecture where a model contains many specialist sub-networks ("experts") but only activates a few for any given input — like a hospital routing you to the right department instead of consulting every doctor. Delivers big-model capability at a fraction of the running cost, and most frontier models now use it.

A long-running benchmark of exam-style questions across dozens of academic subjects — for years the standard "how smart is it" number in model announcements. Top models now near-perfect it, so harder successors keep replacing it.

An AI that works across more than one kind of input and output — text, images, audio, video — in a single model. Show it a photo and ask questions, talk to it out loud, have it watch a screen recording. Most flagship models are now multimodal.

The computing structure underneath modern AI, loosely inspired by how brain cells connect. A neural network is layers of simple math units passing signals to each other; during training, the connection strengths get adjusted millions of times until the network produces useful outputs. Nobody hand-designs what each connection does — the abilities emerge from training, which is also why AI systems can be hard to fully explain.

Neural Radiance Fields are a type of deep learning model that can be used for a variety of tasks, including image generation, object detection, and segmentation. NeRFs are inspired by the idea of using a neural network to model the radiance of an image, which is a measure of the amount of light that is emitted or reflected by an object.

The internal dials an AI model tunes during training — billions of numbers that encode everything it "knows." Parameter count (7B, 70B, etc.) is a rough measure of a model's size and capability, like engine displacement for cars: bigger usually means more powerful, but also more expensive to run.

A model built to think before answering — spending extra computation working through a problem step by step (sometimes visibly, sometimes hidden) before responding. Dramatically better at math, code, and planning; slower and pricier per answer. Consumer apps often call this "thinking mode."

An older architecture that processed sequences one step at a time while carrying a running memory. Largely displaced by transformers (which read everything at once), but you'll still meet the term in AI history and in some audio and time-series work.

A deliberately compact language model — cheaper, faster, and small enough to run on a phone or laptop. The tradeoff is capability, but for focused jobs (summarize this, classify that) small models are often all you need.

A newer architecture family (Mamba is the famous one) challenging transformers by processing long sequences more efficiently. Worth knowing because "transformer alternative" headlines are usually about these.

The benchmark for AI coding agents: real bugs and issues from real open-source projects, scored on whether the AI actually fixes them. When a lab claims its model "solves 70% of SWE-bench," this is what they mean.

Letting an AI "think longer" on hard problems by spending more computing power at answer time — exploring multiple approaches before responding — instead of only making the model bigger. It's why some models now pause and reason before answering, and why harder questions can cost more.

The neural-network architecture behind essentially every modern AI model (the "T" in GPT). Its breakthrough was "attention" — weighing every word in the input against every other — which turned out to scale spectacularly well with more data and computing power.

A list of numbers used to represent something — a word, an image, a document — in a form machines can compare mathematically. When AI systems judge that two things are 'similar,' they're measuring the distance between vectors.

A model that understands images and text together — show it a chart, a screenshot, or a photo of your fridge and ask questions about it. The capability behind "upload an image" features in modern chatbots.

The learned numbers inside a model — same thing as parameters. "Downloading the weights" means getting the actual trained model file; "open weights" means anyone is allowed to.

An AI's internal simulation of how the world works — objects, physics, cause and effect — used to predict what happens next. A hot research direction (and the bet behind JEPA and advanced video models): systems that understand the world, not just its text.

When an AI works through a problem step by step — "first this, then that, therefore…" — instead of jumping straight to an answer. Showing its work measurably improves accuracy on math, logic, and planning, which is why modern "reasoning" models are built around it.

The model's generated output — the answer to your prompt. The word survives from the pre-chat era, when models literally completed whatever text you started.

The evolution of prompt engineering: designing everything the model sees — instructions, documents, tools, memory, examples — not just the wording of one request. As AI systems got more complex, 'what should be in the context?' became the real craft.

The way long AI conversations degrade — accumulated corrections, dead ends, and contradictions confuse the model until answers get worse. The fix is unglamorous: start a fresh chat and restate what matters.

How much an AI can "keep in mind" at once — the conversation so far, documents you've pasted in, instructions — measured in tokens. When a chat exceeds it, the earliest parts fall out of memory, which is why long conversations sometimes make a model forget what you said at the start.

A mode where an AI spends several minutes autonomously searching, reading dozens of sources, and assembling a cited report — instead of answering from memory in two seconds. One of the clearest 'agents doing real work' features to reach consumers.

Including a few examples of what you want inside your prompt — two or three sample input/output pairs — so the model learns the pattern on the spot. One of the most reliable ways to improve results without any technical work.

The documented tendency of models to pay most attention to the beginning and end of a long context while glossing over the middle. Practical tip that falls out of it: put your most important instructions and facts first or last.

The output length limit — the most a model is allowed to generate in one response. When an answer cuts off mid-sentence, this ceiling is usually why.

Whatever you type (or say) to an AI to get it to do something — a question, an instruction, a half-written paragraph to finish. The quality of the prompt shapes the quality of the answer: context, examples, and specifics all help. The word has become a verb too — "just prompt it to be more formal."

A cost-saving trick where an AI provider remembers the unchanged part of your request (long instructions, a big document) so you don't pay full price to re-send it with every message. It's why long back-and-forth conversations with big documents attached can stay affordable.

Feeding one AI response into the next prompt as a multi-step assembly line: outline first, then draft each section, then edit. Usually beats asking for everything in one giant prompt.

The craft of writing requests that get the best results from an AI — being specific, giving examples, setting a role, breaking tasks into steps. Less about magic words than about clear communication; the same skills that make a good brief for a human freelancer.

A reusable prompt with blanks to fill in — "Summarize [ARTICLE] for [AUDIENCE] in [LENGTH]." How teams and apps make AI output consistent instead of reinventing the ask every time.

A number that anchors the randomness in generation: same prompt + same seed = (nearly) the same output. Essential for reproducing an image you liked or debugging AI behavior.

When AI output appears word by word as it's generated instead of arriving all at once. Purely about experience — the answer takes the same total time, but watching it type feels faster.

Forcing a model to answer in an exact machine-readable format (usually JSON) instead of free-flowing prose — so software can reliably use the answer. The unglamorous feature that makes AI dependable inside real products.

The hidden instructions an AI receives before your conversation starts — its job description, personality, and rules ("You are a helpful assistant. Never reveal…"). When two apps use the same underlying model but behave completely differently, the system prompt is usually why.

A setting that controls how adventurous an AI's answers are. Low temperature = predictable, consistent, factual; high temperature = varied, creative, surprising (and more error-prone). Writing tools often run warm; coding and legal tools run cold.

The small chunks AI models actually read and write — usually word-pieces of about 3-4 characters. "Tokens" are the unit AI usage is measured (and billed) in: roughly 750 words per 1,000 tokens. When a model's pricing says "$X per million tokens," this is what it's counting.

A randomness dial that works alongside temperature: it limits the model to choosing among only the most probable next words. You'll meet it in API settings and power-user tools; most people never need to touch it.

Just asking, with no examples — "translate this to French." Modern models are good enough that zero-shot handles most everyday tasks; reach for few-shot when the format or style really matters.

An AI that doesn't just answer questions but takes actions to complete a goal — browsing the web, writing files, booking things, or using other software on your behalf. Think of the difference between asking a friend for directions (a chatbot) and asking them to just drive you there (an agent).

Many agents deployed at once on a big job — dozens of workers researching, testing, or migrating code in parallel while a supervisor coordinates. The industrial-scale version of multi-agent systems.

The umbrella term for AI that plans, uses tools, and completes multi-step work with minimal hand-holding — the industry's biggest shift since chatbots. If a chatbot answers "how do I get a refund?", agentic AI goes and gets the refund.

Using AI to run tasks end-to-end without a person driving — triaging inboxes, processing invoices, publishing content pipelines. Where classic automation followed rigid rules, AI automation handles the messy, judgment-shaped middle.

An assistant's ability to retain information across conversations — your preferences, your projects, past decisions — instead of starting from zero every chat. Distinct from the context window, which only covers the current conversation.

Community shorthand for a personal autonomous AI assistant that runs continuously across your apps and devices — popularized by the open-source OpenClaw project. People say "my claw" the way they once said "my assistant": it remembers context, takes actions, and keeps working when you're not looking.

AI operating a computer the way you do — looking at the screen, moving the cursor, clicking buttons, typing into apps and websites. The capability that lets agents use software that was never designed for them.

An AI assistant embedded directly inside a workflow — in the code editor, the spreadsheet, the inbox — suggesting and drafting while you stay in control. Also Microsoft's brand name for exactly that, which is why the word is everywhere.

The structured way a model uses tools: instead of just writing text, it outputs 'call this function with these inputs' — check the weather, query a database, send an email — and software executes it. The plumbing underneath most agent behavior. Also called tool calling.

The rules and checks wrapped around an AI system that constrain what it can do — content filters, spending caps, forbidden actions, approval requirements. Guardrails live outside the model, in the surrounding software.

Passing a task from one agent (or the AI) to another agent or a human, with the context transferred along. Clean handoffs are a surprisingly large part of what makes agentic systems reliable.

The scaffolding built around an AI model to turn it from a thing that just talks into a thing that gets work done. On its own, a model can only read text and write text back. A harness wraps it in a loop: it feeds the model a task, hands it tools (searching the web, running code, editing files, calling APIs), runs whatever the model asks for, feeds the results back, and repeats until the job is finished. When people say an AI 'agent,' the harness is the part doing the orchestrating around the raw model. Coding assistants like Claude Code and Cursor are essentially very good harnesses. The same underlying model can feel dramatically more or less capable depending on how well its harness is built.

Keeping a person inside an automated process — reviewing, approving, or correcting the AI's work at key checkpoints. The standard answer to 'how do you deploy AI safely for things that matter.'

LangChain is a library that helps users connect artificial intelligence models to external sources of information. The tool allows users to chain together commands or queries across different sources, enabling the creation of agents or chatbots that can perform actions on a user's behalf. It aims to simplify the process of connecting AI models to external sources of information, enabling more complex and powerful applications of artificial intelligence.

A setup where an AI agent runs repeatedly on its own — checking something, doing work, and reporting back on a schedule or until a goal is met, instead of waiting for you to prompt it each time. "Set it and forget it" for AI: for example, a loop that watches your inbox every morning and drafts replies.

A connector that exposes some tool or data source (your files, a database, an app) to AI assistants via the Model Context Protocol. "There's an MCP server for it" means your assistant can plug into that thing today.

An open standard that lets AI assistants plug into outside tools and data — your files, your calendar, a company database — the way USB lets any device plug into any computer. When an app says it "supports MCP," it means AI assistants can connect to it and actually use it, not just talk about it.

Several AI agents working together with different roles — a researcher, a writer, a critic, a coordinator — passing work between them. Often beats one agent doing everything, for the same reason teams beat solo generalists.

A hugely popular open-source platform for running your own always-on AI assistant ("claw") that works across your apps with memory and automation. Because it's open source, anyone can run it, modify it, and build on it — which is why an entire ecosystem of claw-based tools and even enterprise versions from major companies has grown around it.

The conductor layer of an AI system — deciding which model handles what, in what order, with which tools, and what happens when a step fails. As apps grew from one prompt to many coordinated calls, orchestration became its own discipline.

Add-ons that give an AI app extra powers — connecting it to your email, a booking system, a design tool. Same idea as browser extensions: the core assistant stays the same, and plugins extend what it can reach and do.

A sealed environment where AI-generated code or actions run safely without touching anything real. The reason an AI can execute code for you without an error (or an attack) wrecking your machine.

Packaged abilities you can add to an AI assistant — a folder of instructions and examples that teaches it a specific job, like "edit videos in this style" or "review contracts our way." Install a skill and the assistant knows the workflow; no retraining required.

A synthetic on-screen presenter — a digital human that speaks your script with lip-synced video. Used for training videos, localized content, and news-style presentation without cameras or crews.

A visual glitch in generated content — warped text, melted edges, six fingers. Artifact-spotting is still the fastest way humans clock an image as AI-made.

Keeping the same character recognizable across many generated images or video shots — historically one of the hardest problems in AI art, and a headline feature whenever a model improves at it.

A technique that guides image generation with structural inputs — a pose skeleton, a depth map, an edge sketch — so you control composition precisely instead of gambling on the prompt. A pillar of professional AI image workflows.

The technique behind most AI image and video generators. The model learns by watching pictures dissolve into static, then reverses the process: starting from pure noise and "denoising" step by step into an image that matches your prompt.

AI-translating video into another language in the speaker's own cloned voice, often with lip movements adjusted to match. Collapsing the cost of releasing content globally.

Generating in-between frames to make video smoother or create slow motion — AI inventing the moments between the moments the camera captured.

Art created by algorithms — today usually meaning AI image generators like Midjourney and Stable Diffusion, where you describe a picture and the model paints it. The term predates AI (artists have used rule-based and random systems for decades), but AI collapsed the distance between imagination and image to a single sentence.

Photoshop-style AI editing: select an area, describe what should be there, and the model paints it in — matched to lighting and perspective. The feature that brought image AI to everyone's existing tools.

A dial on image generators controlling how literally the model follows your prompt: low = more creative drift, high = strict obedience (sometimes at the cost of image quality). Worth experimenting with when results feel off.

Editing a selected part of an image with AI — remove the photobomber, change the shirt color, fix the hand — while leaving the rest untouched.

Matching a speaker's mouth movements to audio — the technology behind AI dubbing that actually looks right and talking avatars that don't feel broken.

Telling an image generator what to avoid — 'no text, no extra fingers, no watermark.' Half of practical image-generation skill is knowing what to exclude.

Extending an image beyond its original borders, with AI inventing what the wider scene would look like. Turn a portrait into a landscape; give a cropped photo the rest of its room.

Transcribing spoken audio into written text (technically "automatic speech recognition"). The technology behind meeting transcripts, voice typing, and subtitles; Whisper made high-quality transcription essentially free.

Stable Diffusion generates complex artistic images based on text prompts. It’s an open source image synthesis AI model available to everyone. Stable Diffusion can be installed locally using code found on GitHub or there are several online user interfaces that also leverage Stable Diffusion models.

Splitting finished audio into its ingredients — vocals, drums, bass, instruments — cleanly enough to remix or karaoke-fy any track. Nearly impossible before AI; now a checkbox feature.

Applying the visual style of one image to the content of another — your photo, rendered as a watercolor or in a specific artist's aesthetic.

Temporal Coherence refers to the consistency and continuity of information or patterns across time. This concept is particularly important in areas such as computer vision, natural language processing, and time-series analysis, where AI models need to process and understand data that evolves over time. Temporal coherence can be viewed from different perspectives, depending on the specific application: In computer vision, temporal coherence might refer to the smoothness and consistency of visual content in videos, where objects and scenes should maintain their properties and relationships across frames. In natural language processing, it could refer to the consistency and flow of information in a text or conversation, ensuring that the AI model generates responses or summaries that logically follow previous statements or events. In time-series analysis, temporal coherence could relate to the consistency of patterns and trends in the data, such that the AI model can predict future values based on past observations.

Type a description, get a picture — the core interaction of Midjourney, DALL·E, Stable Diffusion, and the rest. The prompt describes subject, style, mood, and composition; the model paints it in seconds.

Describe a song — genre, mood, lyrics — and get a produced track with vocals. Suno and Udio made this consumer-grade, kicking off the music industry's version of the AI reckoning.

Turning written text into natural spoken audio. Modern TTS is good enough to narrate audiobooks and videos indistinguishably from many human reads — see ElevenLabs in our Top 20.

Type a description, get a video clip — the frontier that Sora-class models opened up. Quality has gone from nightmare fuel to near-cinematic in about three years, which is why every studio is paying attention.

The unsettling feeling when something looks almost — but not quite — human. AI-generated faces and voices live and die by whether they clear it.

Increasing image or video resolution with AI that adds plausible detail rather than just stretching pixels. How small, soft images become print-quality (see Magnific in our reviews).

An AI you talk to in real time — it listens, thinks, and speaks back with human-like timing. The technology answering phones at businesses and powering conversational assistants.

Creating a synthetic copy of a specific person's voice from a sample — sometimes seconds of audio. Legitimate uses (narrating your own content at scale, dubbing) sit right next to obvious abuse potential, so consent is the whole ballgame.

The project of making AI systems actually pursue what humans intend — helpful, honest, harmless — rather than what's literally asked or what maximizes some score. Used for everything from everyday chatbot manners to the long-term problem of controlling very capable systems.

The algorithm that makes neural-network training possible: it traces each error backward through the network to work out how much every connection contributed, so all of them can be nudged in the right direction at once.

When teaching a model something new erases things it already knew — a core challenge in updating models without full retraining. The reason "just teach it the new stuff" is harder than it sounds.

A saved snapshot of a model mid-training — both a safety net (resume after a crash) and how model versions get compared and shipped.

Anthropic's approach to alignment: give the model a written set of principles (a 'constitution') and train it to critique and revise its own outputs against them — reducing reliance on armies of human raters. It's a big part of how Claude is trained.

When information from the test somehow sneaks into training — making a model look brilliant in evaluation and mediocre in reality. The classic silent killer of ML projects, and (as 'contamination') a recurring scandal in model benchmarks.

The unglamorous work of getting raw data ready for AI: cleaning up errors and duplicates, filling gaps, converting formats, and filtering out junk. It's most of the actual labor in machine learning — the quality of what goes in sets the ceiling on what comes out, hence the oldest saying in the field: garbage in, garbage out.

Training a small, fast "student" model to imitate a big, expensive "teacher" model. The student never sees the original training library — it just learns to copy the teacher's answers — and ends up nearly as capable at a fraction of the cost and size.

One complete pass through the training data. "Trained for three epochs" means the model saw every example three times.

Deciding which signals to feed a machine-learning model — turning raw data into the measurements that actually matter, like extracting "days since last purchase" from a sales log. It was once the craft that separated great ML engineers from average ones; deep learning automated much of it by learning its own features, but it still matters for business data.

Taking an already-trained AI model and giving it extra, focused training for a specific job — your company's support emails, legal writing, a certain art style. Much cheaper than training from scratch, like hiring an experienced employee and onboarding them, rather than raising one from birth.

The core learning method: measure the error, calculate which direction each internal setting should move to reduce it, take a small step, repeat billions of times. Like descending a foggy mountain by always stepping downhill.

The settings humans choose about training itself — how fast to learn, how big the batches, how long to train. Distinct from parameters, which the model learns; tuning hyperparameters well is a large part of the craft.

Low-Rank Adaptation: a way to fine-tune a model by training tiny add-on files instead of the whole thing — hours on one GPU instead of weeks on hundreds. In image AI, 'a LoRA' is the standard way to package a custom style or character.

The score training tries to minimize — a running measure of how wrong the model's outputs are. Watching 'the loss curve' go down is literally watching a model learn.

The degradation that happens when models train on too much AI-generated content — like photocopying a photocopy, quality and diversity erode generation by generation. A real concern as the internet fills with AI text.

A deployed model quietly getting worse because the world changed while it stayed frozen — new slang, new products, new fraud patterns. The reason models need monitoring and refreshing, not just launching.

A common problem in machine learning, in which the model performs well on the training data but poorly on new, unseen data. It occurs when the model is too complex and has learned too many details from the training data, so it doesn't generalize well.

Everything done to a model after its giant initial pretraining — instruction tuning, safety training, preference optimization — that turns a raw text-predictor into a useful, well-behaved assistant. Increasingly where the competitive magic lives.

The first, most expensive phase of building an AI model: feeding it a giant portion of text (or images, audio, code) so it learns general patterns of language and the world. It's the "raised on a huge library" stage, before the model is shaped for any specific job.

Training by trial, error, and reward — the AI tries actions, gets points for good outcomes, and gradually learns winning strategies, the way you'd train a dog with treats. It's how AI mastered Go and video games, and a variant of it (reinforcement learning from human feedback, RLHF) is how chatbots learned to be helpful rather than just fluent.

Reinforcement Learning from Human Feedback: humans rank which AI responses they prefer, and the model is trained toward the preferred ones. The technique that made ChatGPT feel helpful instead of merely fluent — and the reason chatbots have the personality they do.

Post-training a model on curated example conversations — "here's a question, here's the ideal answer" — to shape how it responds. The first step in turning a base model into an assistant.

Teaching an AI with labeled examples: here are 10,000 emails marked spam-or-not, learn the difference. The "supervision" is the answer key. It's the workhorse of practical machine learning — fraud detection, medical imaging, recommendation systems — anywhere you have historical examples with known correct answers.

Training data generated by AI rather than collected from the world — used when real data is scarce, private, or expensive. Powerful but risky in excess: models trained too heavily on AI output can degrade (see Model Collapse).

Reusing what a model learned on one task as the starting point for another — the insight that made modern AI economical. Every fine-tune is transfer learning: you inherit billions of dollars of pretraining and add your specifics on top.

The opposite of overfitting: a model too simple or undertrained to capture the real patterns, so it performs poorly everywhere. The goal is the middle — complex enough to learn, constrained enough to generalize.

Teaching an AI with no answer key — just data, from which it finds structure on its own: clusters of similar customers, unusual transactions, hidden patterns. Modern language models are largely built this way: nobody labeled the internet, the model just learned the patterns in it.

Splitting documents into bite-sized pieces before feeding them to an AI system — because retrieval works on passages, not entire PDFs. Chunk size and overlap are the unglamorous knobs that make or break RAG quality.

When we want a computer to understand language, we need to represent the words as numbers because computers can only understand numbers. An embedding is a way of doing that. Here's how it works: we take a word, like "cat", and convert it into a numerical representation that captures its meaning. We do this by using a special algorithm that looks at the word in the context of other words around it. The resulting number represents the word's meaning and can be used by the computer to understand what the word means and how it relates to other words. For example, the word "kitten" might have a similar embedding to "cat" because they are related in meaning. Similarly, the word "dog" might have a different embedding than "cat" because they have different meanings. This allows the computer to understand relationships between words and make sense of language.

One search box over everything a company knows — drives, wikis, tickets, chats — usually with an AI that answers questions with citations instead of just listing links. One of the clearest-ROI uses of corporate AI.

Whether the information an AI works from is current. Models have training cutoffs and documents go stale — freshness is why 'when was this last updated?' matters as much as accuracy.

Tying AI answers to actual sources — retrieved documents, databases, live search — instead of the model's memory. A 'grounded' answer can show receipts; an ungrounded one is trusting the model's recollection.

The organized body of information an AI system can draw on — help docs, wikis, policies, product data. "Connect the AI to your knowledge base" is the standard first step of enterprise AI projects.

Information stored as a web of entities and relationships — "Anthropic → makes → Claude" — rather than as documents. Lets AI systems answer questions that require connecting facts across many sources.

A second, more careful pass over search results — a smarter model re-ordering the initial matches so the truly relevant ones reach the AI. Cheap trick, outsized quality gains in RAG systems.

A technique where the AI looks things up before answering — searching your documents or a database, then writing its answer based on what it found. It's how chatbots answer questions about YOUR data accurately instead of guessing from memory, like an open-book exam instead of a closed-book one.

Search by meaning rather than exact words — a query for "affordable places to eat" finds "cheap restaurants." Powered by embeddings; increasingly blended with classic keyword search ("hybrid search") for the best of both.

A database built for storing and searching embeddings — finding "things similar in meaning" in milliseconds across millions of items. The infrastructure behind most RAG systems and semantic search features.

AI that writes, completes, explains, and debugs code alongside a developer — inside the editor or chat. The single most-adopted AI use case in industry; a large share of new code at major tech companies is now AI-written.

An AI feature that writes and actually executes code to answer your question — crunching a spreadsheet, generating a chart, transforming files. You ask in English; it programs its way to the answer in a sandbox.

Examining code changes for bugs and quality before they ship — traditionally by human peers, now heavily assisted by AI reviewers that catch issues and suggest fixes on every pull request.

The step beyond assistance: an AI that takes a task ("fix this bug," "add this feature"), works the codebase, runs tests, and delivers finished changes — often with minimal supervision. Claude Code, Codex, and the OpenClaw ecosystem live here.

The automated pipeline that tests and ships code changes. Relevant here because AI agents increasingly participate in it — writing code, reviewing it, and being gated by the same automated checks as humans.

The line-by-line comparison showing exactly what changed between two versions of code (or text). How developers — and now AI agents — communicate and review changes precisely.

The website where most of the world's software is stored, shared, and built — including a huge share of open-source AI tools. When a Future Tools listing says "GitHub," it means the tool is code you download and run yourself rather than a polished website: free, powerful, and usually requiring some technical comfort. Owned by Microsoft, and home of the Copilot coding assistant.

A free Google service that runs Python code in your browser on Google's computers — including their GPUs, which is the big draw for AI. It's how many people first run AI models without buying expensive hardware: open a shared notebook, press play, and the code runs in the cloud. Tools listed as "Google Colab" on this site are notebooks like that rather than traditional apps.

The app programmers write code in — like a word processor for software, with error-checking and testing built in. Relevant to AI because coding assistants now live inside IDEs, and "AI IDE" tools can write much of the code themselves.

The programming language of AI — readable enough that beginners can follow it, powerful enough that nearly every AI framework is built for it. If you see installation instructions for an AI tool, they're almost certainly Python. Its dominance is why "can you code?" in AI usually means "do you know Python?"

Building software by describing what you want to an AI in plain English and iterating on the results — often without reading the code it writes. Went from joke to job description as AI coding tools matured; great for prototypes, riskier for anything handling money or private data.

A webhook is a way for one computer program to send a message or data to another program over the internet in real-time. It works by sending the message or data to a specific URL, which belongs to the other program. Webhooks are often used to automate processes and make it easier for different programs to communicate and work together. They are a useful tool for developers who want to build custom applications or create integrations between different software systems.

An input engineered to fool a model — an image imperceptibly modified so a classifier sees something absurd, or text that slips past filters. Proof that models perceive the world very differently than we do.

The rules, policies, and oversight for how AI is built and used — inside companies (usage policies, review boards) and across society (regulation like the EU AI Act). The answer to "who is accountable when the AI does something?"

The field devoted to keeping AI systems from causing harm — spanning everyday issues (toxic outputs, scams, bias) up to long-term concerns about very capable systems. Distinct from security, which protects the AI from attackers.

A tamper-evident label attached to media recording how it was made and edited (the C2PA standard, backed by Adobe, camera makers, and platforms). The 'nutrition label' approach to the what's-real problem.

The systems (increasingly AI themselves) that classify and filter harmful content — in user posts, AI outputs, or both. Every consumer AI product runs moderation layers you never see.

Synthetic media impersonating a real person — a face, a voice, a full video. The go-to term for malicious impersonation, from celebrity scam ads to fake calls from 'family members.'

GLTR is a tool that helps people tell if a piece of text was written by a computer or a person. It does this by looking at how each word in the text is used and how likely it is that a computer would have chosen that word. GLTR is like a helper that shows you clues by coloring different parts of the sentence different colors. Green means the word is very likely to have been written by a person, yellow means it's not sure, red means it's more likely to have been written by a computer and violet means it's very likely to have been written by a computer.

When an AI states something false with total confidence — an invented citation, a fake statistic, a product feature that doesn't exist. It happens because models predict plausible-sounding text rather than checking facts. The practical rule: the more a claim matters, the more you verify it.

Research into understanding what's actually happening inside a model — which internal circuits do what, and why it produced a given answer. Today's models are largely black boxes; interpretability is the effort to open them, and it matters for both trust and safety.

A prompt crafted to trick an AI into ignoring its safety rules — through roleplay, encoding, or clever framing. An endless cat-and-mouse game between model builders and people probing the fences.

The spec sheet published with a model: what it's for, how it was tested, where it fails, what it shouldn't be used for. Reading the model card is the AI equivalent of reading the label.

Formally declining to have your data used — for AI training, personalization, or both. Increasingly offered by platforms; worth knowing where the setting lives on tools you use.

Data that identifies a specific person — names, emails, addresses, faces. The center of most AI privacy questions: what PII went into training, what leaks out in answers, and what your prompts reveal.

Hiding instructions where an AI will read them — inside a webpage, email, or document — so it obeys the attacker instead of the user. The most important new security problem AI created: your assistant reads everything, and attackers know it.

Deliberately attacking your own AI system — trying to make it produce harmful content, leak data, or misbehave — before real adversaries do. Standard practice at serious labs, and increasingly demanded by regulators.

A frontier lab's published commitment tying model development to safety thresholds — "we won't train/deploy past capability X without safeguard Y." Anthropic pioneered the format; how labs try to demonstrate they can self-govern.

Any content generated or substantially altered by AI — the neutral umbrella term covering everything from harmless avatars to deepfakes. Increasingly paired with disclosure rules and provenance standards.

The unresolved legal battleground over what data may train AI models — scraped articles, books, art, code — and what creators are owed. The subject of landmark lawsuits whose outcomes will shape the whole industry.

Embedding an invisible, detectable signature into AI-generated content so tools can identify it later. Appealing in theory, brittle in practice — watermarks often survive casual sharing but not determined removal.

CUDA is a way that computers can work on really hard and big problems by breaking them down into smaller pieces and solving them all at the same time. It helps the computer work faster and better by using special parts inside it called GPUs. It's like when you have lots of friends help you do a puzzle - it goes much faster than if you try to do it all by yourself. The term "CUDA" is a trademark of NVIDIA Corporation, which developed and popularized the technology.

What AI usage actually costs — providers price per million tokens in and out. The number falling ~10x every year or two, which is what keeps making previously absurd AI applications economical (see Jevons Paradox).

The warehouse-scale buildings full of servers where AI actually runs — now the defining capital expense of the AI era, consuming gigawatts and driving nuclear-power deals. "Compute buildout" headlines are about these.

Thousands of GPUs wired together to act as one giant computer — the factory where frontier models are trained. Cluster size (in GPUs or megawatts) has become the industry's favorite measure of AI ambition.

A GPU, or graphics processing unit, is a special type of computer chip that is designed to handle the complex calculations needed to display images and video on a computer or other device. It's like the brain of your computer's graphics system, and it's really good at doing lots of math really fast. GPUs are used in many different types of devices, including computers, phones, and gaming consoles. They are especially useful for tasks that require a lot of processing power, like playing video games, rendering 3D graphics, or running machine learning algorithms.

A company whose business is hosting models and serving predictions fast and cheap — the "power utilities" of AI that most apps quietly run on.

Running models on your own hardware — laptop, phone, home server — instead of a provider's cloud. Total privacy and no subscription, traded against capability and setup effort; the open-weights ecosystem is what makes it possible.

The decades-old observation that computer chips roughly double in capability every couple of years for the same price. It's the backdrop for AI economics — and you'll hear "faster than Moore's Law" to describe how quickly AI performance-per-dollar is currently improving.

The AI accelerator inside modern phones and laptops — dedicated silicon for running models on-device. The hardware behind "AI PC" marketing and features that work without the cloud.

A compression trick that shrinks an AI model by storing its numbers less precisely — like rounding prices to the nearest dollar. The model gets much smaller and faster (often enough to run on a laptop or phone) while giving up only a little quality.

A serving trick where a small fast model drafts the next several words and the big model just verifies them — much faster generation, identical quality. One of many invisible optimizations behind cheaper, snappier AI.

Google's custom AI chip — its in-house alternative to NVIDIA GPUs, powering Gemini's training and much of Google's AI infrastructure. When Google touts training runs 'on TPUs,' it's flexing independence from the GPU supply chain.

The speed a model generates output — its words-per-minute. The difference between an assistant that feels instant and one you watch think; a favorite spec in model and chip announcements.

A GPU's onboard memory — the hard limit on what models you can run locally, since the whole model must fit inside it. The first spec to check before trying to run open models at home; the reason quantized versions exist.

Buying a company mainly for its people rather than its product. AI's talent scarcity made variants of this — including licensing deals that hollow out startups for their researchers — a signature move of the era.

The recurring worry that AI valuations and infrastructure spending have outrun real revenue. Whatever your view, know the frame: bulls point to genuine usage and falling costs, bears to circular deals and capex outpacing returns.

Marketing something as "AI-powered" when the AI is trivial or absent — the era's version of greenwashing. Regulators have started charging companies for it.

A product that is mostly a thin layer over someone else's model — dismissively, "just a ChatGPT wrapper." The insult fades as some wrappers grow real moats (workflow, data, distribution); the lesson is that the model is rarely the product.

Built around AI from day one rather than having AI bolted on — said of products, companies, and increasingly people's workflows. The mobile-native playbook, replayed.

Capital expenditure — in AI coverage, the staggering sums (hundreds of billions across big tech) going into data centers, chips, and power. The single biggest financial storyline of the AI era.

A proprietary model you can only reach through the maker's app or API — you rent the capability, never hold the weights. The GPT/Claude/Gemini mainline is closed; the tension between closed quality and open control shapes the industry.

You might see the term "Freemium" used often on this site. It simply means that the specific tool that you're looking at has both free and paid options. Typically there is very minimal, but unlimited, usage of the tool at a free tier with more access and features introduced in paid tiers.

One of the handful of organizations building the most capable models — OpenAI, Anthropic, Google DeepMind, Meta AI, xAI, and a few others. Their releases, safety policies, and rivalries drive most AI news cycles.

The economic observation that making something cheaper to use often increases total spending on it, because people use vastly more. Cited constantly in AI: as the cost per AI answer collapses, overall AI usage (and computing demand) explodes rather than shrinks — good news for chipmakers, and the standard rebuttal to "cheaper AI means less demand for GPUs."

A durable competitive advantage. In AI the candidates are compute (who can afford the chips), data (what you alone can train on), and distribution (who already has the users) — and the industry debate is which moats actually hold as models commoditize.

AI tools usable without programming — drag-and-drop workflow builders, natural-language app creators. Paired with "low-code" (minimal programming), it's how AI capability reaches the 99% of people who don't write software.

Software whose full recipe is public: anyone can inspect, run, modify, and share it, usually for free. In AI, "open source" (or "open weights") means you can download the model itself and run it on your own machines — no dependence on one company's servers, pricing, or rules.

A model whose trained weights are downloadable — you can run it yourself, fine-tune it, build on it. Not necessarily fully 'open source' (training data and code may stay private), which is why the pedantic distinction keeps coming up.

The company behind ChatGPT, the GPT model family, the DALL-E and Sora image and video generators, and the Codex coding agent. Founded in 2015 as a nonprofit research lab, it became the defining commercial force in AI after ChatGPT's 2022 launch triggered the current boom. Its releases — and its rivalries with Anthropic, Google, and open-source projects — drive a huge share of AI news.

AI deployed so your data never leaves your control — on-premises or in a locked-down cloud. What regulated industries mean when they say they "can't use ChatGPT" but still want the capability.

A deliberately limited early release — "try it, but it's not a product yet." The step before public beta and General Availability (GA), and often where the wildest capabilities first appear.

The empirical finding that model capability improves predictably as you add compute, data, and parameters — the "just make it bigger" curve that justified billion-dollar training runs. Whether the curve is flattening is a perpetual industry argument.

Nations building their own AI infrastructure, models, and data pipelines rather than depending on foreign providers — treated as strategic policy the way energy independence is. A major driver of global data-center and chip spending.

How AI APIs charge: per million tokens, with input (what you send) and output (what it generates) priced separately, and output typically costing more. Reasoning models add "thinking" tokens to the bill.

Becoming so dependent on one provider that switching is impractical — a live concern when your workflows, prompts, and data pipelines are built around a single AI vendor. The case for model-agnostic tooling.

A living virtual replica of something real — a factory, a building, a machine — kept in sync with its physical counterpart so you can simulate, test, and optimize without touching reality.

AI with a body — physical (robots) or simulated — that must perceive, move, and act in the real world rather than just process text. The frontier where AI progress meets physics.

A robot with roughly human form — built that way so it can work in spaces and with tools designed for humans. The category (Optimus, Figure, and peers) betting that general-purpose beats special-purpose.

Laser-based distance sensing that builds precise 3D maps of surroundings — a core sensor for self-driving cars and robots (and the thing Tesla famously bets against in favor of cameras).

Training robots in simulation (where practice is fast, cheap, and safe) and transferring the learned skills to physical hardware. The gap between the two is one of robotics' central challenges.

Humans remotely piloting robots — both a product (dangerous-environment work) and, importantly, how training data for robot AI gets collected: people demonstrate, robots learn to imitate.

A model that connects seeing and language understanding directly to physical action — "pick up the red cup" goes from camera pixels to motor commands in one system. The foundation-model approach applied to robots.

How fast the transition to transformative AI happens once it starts — "hard takeoff" (explosive, months), "soft takeoff" (gradual, years-to-decades). The variable that determines how much time society gets to adapt.

The hypothetical point where AI matches or exceeds humans across most economically valuable work, not just narrow tasks. There's no agreed test for it and definitions vary wildly by company — which is worth remembering whenever a headline claims it's near.

Hypothetical AI that surpasses human ability across essentially everything — the stage beyond AGI. The stakes-raising term in debates about where all this leads.

The gap between what current AI can already do and what anyone has figured out how to use — meaning even a total freeze on new models would leave years of transformation in the pipeline.

The movement (and Twitter identity) holding that technological acceleration is a moral good and slowing AI is the real danger — the cultural opposite of safety-first "decels." The suffix in bios tells you the priors.

Abilities that show up in AI models that nobody explicitly taught them — like a model trained mostly on English suddenly translating, or doing arithmetic. These capabilities "emerge" as models get bigger, and they're a big part of why AI progress keeps surprising even the people building it.

An alternative AI architecture championed by Meta's chief AI scientist Yann LeCun, designed to learn how the world works by predicting the meaning of what happens next rather than every pixel or word. The bet: models that build an internal "world model" this way could reason and plan more like animals do, addressing what LeCun argues are fundamental limits of chatbot-style AI. Worth knowing because it's the highest-profile challenge to the current LLM playbook.

AI that excels at one specific thing — chess, transcription, protein folding — with no ability outside it. Everything deployed today is technically narrow, though frontier models keep stretching the word.

Someone's personal probability that AI ends catastrophically for humanity — asked half-jokingly at AI dinner parties and answered seriously by researchers, with famous figures ranging from ~0% to >50%. A cultural shorthand for where you sit on AI risk.

The scenario where AI improves its own design, and each improvement makes it better at improving itself — the feedback loop behind "intelligence explosion" and hard-takeoff arguments. Early real-world echoes: AI labs using AI to accelerate AI research.

The hypothetical point where AI becomes capable of improving itself faster than humans can keep up, triggering runaway technological change nobody can predict or reverse. Long a sci-fi staple, it's now debated seriously — usually as the far end of the AGI conversation. When someone in AI says "post-singularity," they mean "all bets are off after that."

Spatial computing is the use of technology to add digital information and experiences to the physical world. This can include things like augmented reality, where digital information is added to what you see in the real world, or virtual reality, where you can fully immerse yourself in a digital environment. It has many different uses, such as in education, entertainment, and design, and can change how we interact with the world and with each other.

Rich Sutton's famous essay-turned-proverb: over 70 years, general methods that leverage raw computation keep beating clever human-crafted approaches. Quoted constantly to argue for scale over ingenuity — and why the GPU buildout continues.

The framing of AI agents as digital staff — "hire" an AI SDR, support rep, or analyst. Part product category, part hype; the useful question underneath is which jobs-to-be-done actually hold up.

Low-effort AI-generated content flooding feeds, search results, and marketplaces — generic articles, uncanny images, spam books. The word that stuck for the pollution problem, and the reason "human-made" is becoming a selling point.

The 2017 Google paper that introduced the transformer — plausibly the most consequential AI paper ever, and now a constant cultural reference. Its eight authors went on to found a striking share of the AI industry.

Tuning a model to ace public tests rather than to be genuinely better — why every release announcement shows record scores and users still argue about which model is actually smarter (see Vibe Check).

The standard framing for AI autonomy: copilot = AI assists while you drive; autopilot = AI acts on its own within limits. Most products are deliberately positioned somewhere on this line — and say so.

The idea that AI leverage will let a single founder build a billion-dollar company — the thought experiment (attributed to Sam Altman) that became a startup-culture benchmark for what agents change.

A personal knowledge system — notes, documents, saved everything — made genuinely useful by AI that can search and reason over it. The productivity movement AI finally delivered on.

The famous critique that language models merely remix patterns from training data without understanding — from a 2021 paper that became shorthand for the skeptical position in the "do they really think?" debate.

Informal, subjective model testing — skip the benchmarks, just talk to it and see how it feels. Taken semi-seriously because polished benchmark scores routinely fail to predict which model people actually prefer.