The AI glossary
that gets you back
to the right word, fast.

— Technical basics

LLM

An LLM is an AI model trained to understand and generate language.

Where you'll run into it: It's hiding behind ChatGPT, Claude, Gemini, Perplexity, and a lot of assistants built into your tools.

— Technical basics

SLM

An SLM is a smaller language model, often faster and cheaper than a big LLM.

Where you'll run into it: You run into it in local use cases, simple high-volume tasks, or automations that need to stay cheap.

— Technical basics

Inference

Inference is the moment when the model produces an answer from your request.

Where you'll run into it: It's what you pay for on every API call or every message handled by a hosted model.

— Technical basics

Context window

The context window is how much text a model can take into account in a single conversation or request.

Where you'll run into it: You'll see it when a tool refuses a PDF that's too long, cuts off a conversation, or advertises 128k, 200k, or 1M tokens.

— Prompting

System prompt

The system prompt is the top-level instruction that frames how the model behaves during the conversation.

Where you'll run into it: You run into it in AI APIs, custom instructions, AGENTS.md, CLAUDE.md, or agent builders.

— Performance

Streaming

Streaming shows you the answer as the model generates it.

Where you'll run into it: You'll see it in chat interfaces where the words appear one after another.

— Prompting

Prompt engineering

Prompt engineering means phrasing a request with enough context, examples, and constraints to get a useful answer.

Where you'll run into it: You practice it in ChatGPT, Claude, Gemini, Codex, n8n, or any tool that asks for an instruction.

— Prompting

Few-shot / Zero-shot

Zero-shot means asking with no example. Few-shot means giving a few examples before your request.

Where you'll run into it: Handy for locking in a stable format, classifying data, or copying a structure.

— Prompting

Chain of thought

Chain of thought is the step-by-step reasoning a model can work through before it answers.

Where you'll run into it: You mostly hear it around logic, planning, math, and reasoning models.

— Prompting

Temperature

Temperature is a setting that influences how varied and risk-taking the model's answers are.

Where you'll run into it: You'll see it in AI APIs, some playgrounds, and automation tools.

— Prompting

Top-p / Top-k

Top-p and Top-k narrow the pool of possible next words during generation.

Where you'll run into it: You see them in advanced API settings, often without ever needing to touch them.

— Prompting

Stop sequence

A stop sequence tells the model where to stop its answer.

Where you'll run into it: Handy in structured extraction, repeatable prompts, and certain scripts.

— RAG

RAG

RAG lets an AI answer using documents pulled up at the moment you ask the question.

Where you'll run into it: You run into it in documentation chatbots, internal knowledge bases, and agents that cite their sources.

— RAG

Embedding

An embedding turns a piece of text into a list of numbers so you can compare its meaning with other texts.

Where you'll run into it: You run into it in RAG, semantic search, vector databases, and recommendation engines.

— RAG

Vector database

A vector database stores embeddings and finds the texts closest to a question.

Where you'll run into it: You see it in Pinecone, Qdrant, Weaviate, Supabase pgvector, or document-chatbot architectures.

— Agent

Tool use / Function calling

Tool use lets a model call an external tool instead of only replying with text.

Where you'll run into it: You see it in agents that send an email, read a file, search the web, or call an API.

— Agent

Computer use

Computer use lets an AI read a screen, click, and type like a real user.

Where you'll run into it: You'll see it in browser agents, visual testing, and some web automations.

— Advanced RAG

Grounding

Grounding means anchoring an answer in sources that were provided or retrieved.

Where you'll run into it: You'll see it in answers with citations, web-augmented search, and document chatbots.

— Advanced RAG

Chunking

Chunking splits a long document into pieces an AI search system can actually work with.

Where you'll run into it: It's a key step when you build a RAG on top of PDFs, pages, or knowledge bases.

— Advanced RAG

Reranking

Reranking re-sorts the results you found so the model gets the most relevant passages.

Where you'll run into it: You see it in semantic search engines and RAG systems that need to cite precisely.

— Agent

Agentic workflow

An agentic workflow is a sequence of steps where the AI plans, uses tools, checks its work, and keeps going until it hits the result.

Where you'll run into it: You run into it in Codex, Claude Code, n8n, curation agents, and any automation with several decisions along the way.

— Agent

Orchestration

Orchestration organizes the steps, tools, or agents needed to reach a result.

Where you'll run into it: You see it in multi-step workflows, content pipelines, specialized agents, and tools like n8n.

— Agent

Handoff

A handoff is passing a task from one agent to another agent better suited to it.

Where you'll run into it: You'll see it in systems with a greeter agent, a research agent, a writing agent, or a support agent.

— Agent

Multi-agent

A multi-agent system puts several specialized agents to work on the same mission.

Where you'll run into it: You see it in complex research, code reviews, monitoring, and editorial pipelines.

— Memory

Short-term memory

Short-term memory is what the agent holds on to during the current session.

Where you'll run into it: It explains why an agent remembers its latest actions, but not necessarily tomorrow.

— Memory

Long-term memory

Long-term memory keeps useful preferences or facts across several sessions.

Where you'll run into it: You'll see it in custom instructions, AGENTS.md files, CLAUDE.md, or business agents.

— Control

Context engineering

Context engineering is about giving the model the right documents, rules, examples, and tools at the right time.

Where you'll run into it: You'll see it in agents, RAG, instruction files, and workflows that pick the context before answering.

— Control

Structured output

Structured output forces an AI to reply in a precise format, often JSON, so a tool can reuse it.

Where you'll run into it: You run into it in data extraction, automations, agents wired to a database, and generated forms.

— Evaluation

Evaluation / Eval

An eval regularly measures whether an AI answers correctly on representative cases.

Where you'll run into it: You'll see it when comparing two prompts, two models, or two versions of an agent.

— Evaluation

Observability / Tracing

Observability shows an agent's inner steps: prompts, tools called, errors, and time spent.

Where you'll run into it: You run into it in LangSmith, agent dashboards, and execution logs.

— Security

Guardrail

A guardrail is a safety rule that limits what an AI or an agent is allowed to do.

Where you'll run into it: You'll see it in agents that can send, publish, edit, delete, or access sensitive data.

— Security

Human-in-the-loop

Human-in-the-loop means a person validates a step before an agent runs a sensitive action.

Where you'll run into it: You see it in email, finance, publishing, and customer support agents, or any automation with real-world impact.

— Security

Indirect prompt injection

An indirect prompt injection hides malicious instructions inside content that the agent reads.

Where you'll run into it: You run into it around agents that read web pages, emails, documents, or support tickets.

— Customization

Fine-tuning

Fine-tuning adapts an existing model on examples to improve one specific behavior.

Where you'll run into it: You see it on AI platforms, open-weight models, and projects with lots of high-quality examples.

— Customization

LoRA / QLoRA

LoRA is a lightweight fine-tuning method that adjusts only a small part of the model.

Where you'll run into it: You see it in open-weight communities and tutorials for adapting local models.

— Customization

Quantization

Quantization lowers a model's internal precision to save memory and gain speed.

Where you'll run into it: You'll see it in Ollama, LM Studio, and any model running locally.

— Customization

Distillation

Distillation trains a small model to imitate a more powerful one.

Where you'll run into it: You see it when the goal is to cut costs while keeping quality close.

— Performance

TTFT

TTFT measures the time between sending your request and the first token showing up.

Where you'll run into it: You see it in chat interface metrics and model benchmarks.

— Performance

TPS

TPS measures how many tokens a model generates per second.

Where you'll run into it: You see it in speed benchmarks, especially for long answers.

— Performance

Latency

Latency is the total delay you feel between your request and the answer.

Where you'll run into it: You'll see it in chat interfaces, voice agents, and real-time automations.

— Risk

Hallucination

A hallucination is a made-up or wrong answer that the model presents with full confidence.

Where you'll run into it: You run into it in nonexistent citations, wrong numbers, invented functions, or overly confident summaries.

— Risk

Prompt injection

A prompt injection tries to hijack the instructions of a model or an agent.

Where you'll run into it: You'll see it in agents that read outside content, public chatbots, and tools connected to the web.

— Risk

Jailbreak

A jailbreak tries to get around a model's safety rules.

Where you'll run into it: You mostly hear it in AI safety discussions and robustness testing.

— Modality

Multimodal

A multimodal model accepts several types of input, like text, images, audio, or video.

Where you'll run into it: You'll see it when an AI analyzes a screenshot, transcribes a voice, or understands an image.

— Modality

Vision model

A vision model understands or describes images.

Where you'll run into it: You run into it when analyzing screenshots, photos, charts, tables, and scanned documents.

— Modality

TTS / STT

TTS turns text into speech. STT turns speech into text.

Where you'll run into it: You see them in voice assistants, AI podcasts, subtitles, and transcriptions.

— Modality

Diffusion model

A diffusion model generates an image by starting from noise, then gradually transforming it.

Where you'll run into it: You see it in image and illustration generation tools.

— Concept

AGI / ASI

AGI means a general-purpose AI at human level. ASI means an AI that would go far beyond humans.

Where you'll run into it: You hear it in debates about the long-term trajectory of artificial intelligence.

— Concept

Open source vs open weight

Open weight means the model's weights are available. Open source also implies more transparency about the code, and sometimes the data.

Where you'll run into it: You'll see it in discussions around Llama, Mistral, Qwen, Hugging Face, and local models.

— Concept

Reasoning model

A reasoning model takes more time to think before answering a complex task.

Where you'll run into it: You run into it in thinking options, problem-solving models, and planning tasks.

— Codex

AGENTS.md

AGENTS.md is an instructions file Codex reads to follow a project's rules.

Where you'll run into it: You see it at the root of a project used with Codex.

— Codex

Codex CLI

Codex CLI is the local interface that lets Codex read a project, propose changes, and run commands.

Where you'll run into it: You see it in Codex tutorials, local projects, and sessions where the agent works right inside the files.

— Codex

Codex web

Codex web is the browser interface for tracking or launching Codex tasks without staying in the terminal.

Where you'll run into it: You run into it for long-running tasks, reviews, and work kicked off remotely.

— GitHub

Git

Git keeps the history of a project's changes and lets you roll back.

Where you'll run into it: You'll see it in GitHub, commits, branches, pull requests, and deployments.

— GitHub

Commit

A commit is a named save point in the Git history.

Where you'll run into it: You see it in the GitHub history and in the changes an agent prepares.

— GitHub

Branch

A branch is a separate line of work kept apart from the main version.

Where you'll run into it: You see it when a change is prepared without touching production directly.

— GitHub

Pull request

A pull request proposes merging a branch into the main project after review.

Where you'll run into it: You see it on GitHub, before a merge and a deployment.

— Automation

Webhook

A webhook is a URL that gets called automatically when an event happens.

Where you'll run into it: You'll see it between forms, payments, CRMs, emails, and AI agents.

— Supabase

RLS

RLS defines which rows of a Supabase database each user is allowed to read or edit.

Where you'll run into it: You see it in projects with user accounts and private data.

— Vercel

Vercel environment variables

Vercel environment variables store sensitive keys and settings on the deployment side.

Where you'll run into it: You set them in your Vercel project settings, instead of writing them into public code.

— No-code

n8n Workflow

An n8n workflow is an automation made of steps linked together.

Where you'll run into it: You'll see it for wiring up forms, emails, databases, AI, and webhooks.

— Connection

OAuth 2.0

OAuth lets a tool access an account without ever giving it your password.

Where you'll run into it: You'll see it in the "Sign in with Google, Slack, Notion, or GitHub" buttons.

— Agent

Subagent

A subagent is a specialized assistant I hand a specific slice of the work to.

Where you'll run into it: You run into it in Codex, Claude Code, research workflows, reviews, and multi-agent curation.

— Security

Tool permission

A tool permission decides what an agent is allowed to read, write, or run.

Where you'll run into it: You see it in Codex, Claude Code, MCP, connectors, and any tool that can act on your files.

— Security

Approval mode

Approval mode decides when the agent can act on its own and when it has to ask for the go-ahead.

Where you'll run into it: You run into it before a shell command, a file change, an email send, or a sensitive MCP action.

— Security

Sandbox

A sandbox isolates the agent to limit the damage if an action goes wrong.

Where you'll run into it: You see it in Codex cloud, agents that run code, tests, and controlled environments.

— Tools

Shell tool

A shell tool lets an agent propose or run commands in a controlled terminal.

Where you'll run into it: You'll come across it in Codex, the Agents SDK, local testing, and automations that handle files.

— Security

Allowlist / Denylist

An allowlist permits only what's planned; a denylist blocks what's risky.

Where you'll run into it: You see them used to limit shell commands, web domains, MCP servers, or which tools are reachable.

— Security

Access scope

Access scope defines the exact perimeter a token or a tool is allowed to use.

Where you'll run into it: You run into it in OAuth, MCP, API keys, GitHub permissions, and automation connectors.

— Security

Least privilege

Least privilege means giving the agent only the rights it actually needs.

Where you'll run into it: You run into it in MCP, Supabase, GitHub, API keys, and any agent able to act inside a real tool.

— MCP

Local MCP server

A local MCP server runs on your machine and exposes files, tools, or commands to the AI.

Where you'll run into it: You run into it in Claude Desktop, Claude Code, Codex, and file or local-database connectors.

— Agent

Tool loop

A tool loop alternates the AI thinking, a tool call, a result, then the next step.

Where you'll run into it: You'll see it in Codex, the Agents SDKs, the Vercel AI SDK, and research agents that move forward step by step.

— Agent

Loop limit

A loop limit keeps an agent from running too long or repeating the same actions.

Where you'll run into it: You run into it in autonomous agents, n8n workflows, monitoring scripts, and tool calls stuck in a loop.

— Agents

Checkpoint

A checkpoint saves an agent's state so it can pick back up cleanly later.

Where you'll run into it: You run into it in long workflows, human approvals, LangGraph, and agents that need to survive a pause.

— Agent

Interrupt

An interrupt pauses the agent so a person can approve, correct, or fill something in.

Where you'll run into it: You run into it before sending an email, a financial action, publishing, or a sensitive change.

— Agent

Supervisor

A supervisor is the agent that splits the work across several specialized agents.

Where you'll run into it: You see it in multi-agent systems, monitoring setups, code reviews, and complex research workflows.

— Risk

Excessive agency

Excessive agency happens when an agent has too much autonomy, too many tools, or too many rights.

Where you'll run into it: You'll run into it in OWASP discussions and in agents that can write, delete, publish, or call external tools.

— RAG

Knowledge base

A knowledge base is the organized folder the AI searches before it answers.

Where you'll run into it: You run into it in documentation assistants, Bedrock, Vertex AI Search, LangChain, Notion, or a team's internal docs.

— Data

Document ingestion

Ingestion imports documents so they can be cleaned, chunked, and made searchable.

Where you'll run into it: You'll run into it when you plug PDFs, web pages, Drive folders, or Notion bases into a RAG system.

— Data

Data connector

A data connector goes and fetches information from where it already lives.

Where you'll run into it: You see it for Google Drive, Slack, Notion, SharePoint, Confluence, Supabase, or local folders.

— RAG

Document indexing

Indexing prepares the chunks of your documents so a search can find them fast.

Where you'll run into it: You run into it in vector databases, Azure AI Search, OpenAI Retrieval, and RAG pipelines.

— Advanced RAG

Retriever

A retriever pulls the most useful passages before the AI writes its answer.

Where you'll run into it: You see it in LangChain, LlamaIndex, GraphRAG, RAG agents, and document architecture diagrams.

— RAG

Semantic search

Semantic search finds the meaning of a question, even when the exact words change.

Where you'll run into it: You run into it in RAG, embeddings, vector databases, and internal search engines.

— Advanced RAG

Hybrid search

Hybrid search combines keywords and semantic search to pull back more of the right passages.

Where you'll run into it: You see it in Weaviate, Pinecone, Azure AI Search, and RAG systems that need to be reliable on business content.

— Advanced RAG

BM25

BM25 is a keyword search method that stays useful when the exact terms matter.

Where you'll run into it: You'll run into it in full-text engines, hybrid search, and RAG architectures that don't bet everything on vectors.

— Data

Metadata

Metadata is the info around a document: source, date, author, type, client, or folder.

Where you'll run into it: You run into it in RAG documents, search filters, knowledge bases, and CRM exports.

— Documents

Document parsing

Parsing turns a PDF or a page into text, headings, tables, and sections an AI can work with.

Where you'll run into it: You run into it in Document AI, Azure Document Intelligence, LlamaParse, and workflows that read contracts or invoices.

— Documents

Structured extraction

Structured extraction asks the AI to pull clean fields out of a document.

Where you'll run into it: You see it for turning emails, invoices, contracts, forms, or PDFs into usable data.

— Advanced RAG

Query rewriting

Query rewriting reformulates a vague question so it searches your documents better.

Where you'll run into it: You run into it in search agents, advanced RAG, and engines that reshape a question before searching.

— Advanced RAG

Agentic RAG

Agentic RAG lets the agent decide when to search, what to search for, and when to search again.

Where you'll run into it: You'll see it in research assistants, Azure agentic retrieval, LangChain, and watch/curation agents.

— Advanced RAG

GraphRAG

GraphRAG adds a graph of relationships to answer questions that need a big-picture view.

Where you'll run into it: You run into it in Microsoft GraphRAG, knowledge graphs, and analyses of large document corpora.

— Sources

Source citations

Citations show exactly where an answer comes from, so I can verify it.

Where you'll run into it: You see them in Claude, Perplexity, ChatGPT Search, document RAGs, and monitoring agents.

— API

Model ID

The model ID is the exact name you put into a tool or an API to pick the engine that answers.

Where you'll run into it: You'll run into it in the OpenAI, Claude, and Gemini APIs, the Vercel AI SDK, n8n, or an agent's settings.

— API

Model provider

The model provider is the platform that gives you access to the model you're using.

Where you'll run into it: You'll see it when you choose between OpenAI, Anthropic, Google, Mistral, Hugging Face, Vercel, or OpenRouter.

— OpenAI API

Responses API

The Responses API is OpenAI's modern entry point for requesting an answer and plugging in tools.

Where you'll run into it: You run into it in the OpenAI docs, the SDKs, agents, the web search tool, file search, and some projects generated with Codex.

— API

OpenAI-compatible API

An OpenAI-compatible API lets you use nearly the same code with a different provider.

Where you'll run into it: You see it with Gemini, Hugging Face, OpenRouter, some gateways, and tools that let you swap providers.

— AI tools

Web Search tool

The Web Search tool lets the model go check the web before it answers.

Where you'll run into it: You run into it in OpenAI, Gemini with Google Search, ChatGPT Search, Claude Search, and news-watching agents.

— AI tool

File Search tool

File Search lets the model search through your files before it answers.

Where you'll run into it: You see it in OpenAI Responses, Gemini File Search, document assistants, and projects that read PDFs.

— AI tool

Code Interpreter

Code Interpreter lets an AI write and run code in an isolated space to calculate or analyze.

Where you'll run into it: You run into it in ChatGPT, AI APIs, CSV analysis, charts, calculations, and quick prototypes.

— Performance

Prompt caching

Prompt caching reuses the stable part of your context so the model runs faster and costs less.

Where you'll run into it: You'll see it in OpenAI, Anthropic, Gemini, Claude Code, and any agent that keeps resending the same big documents.

— Control

Reasoning effort

Reasoning effort sets how much effort the model puts into thinking before it answers.

Where you'll run into it: You run into it in reasoning models, APIs, Gemini thinking, Claude extended thinking, and some Codex settings.

— AI product

Deep Research

Deep Research runs a long search, cites its sources, and hands back a structured report.

Where you'll run into it: You see it in ChatGPT, Gemini, the OpenAI API, curation agents, and in-depth research workflows.

— AI product

Custom GPT

A Custom GPT is a personalized ChatGPT with its own instructions, files, and actions.

Where you'll run into it: You run into it in ChatGPT, the GPT Builder, internal assistants, and no-code tools built around OpenAI.

— AI product

NotebookLM

NotebookLM turns your sources into a research assistant that cites the documents you feed it.

Where you'll run into it: You'll see it at Google, working with PDFs, Google Docs, YouTube videos, audio overviews, and sourced research.

— Claude Code

Claude Code

Claude Code is Claude's agent: it reads a project, edits files, and runs commands with your approval.

Where you'll run into it: You'll run into it in terminal tutorials, agents, GitHub Actions, code reviews, and project automations.

— Claude Code

CLAUDE.md

CLAUDE.md is the file where you write down a project's rules so Claude doesn't start from scratch.

Where you'll run into it: You see it at the root of a project, inside .claude folders, in agent tutorials, and in shared configs.

— Tools

Slash command

A slash command is a short command that fires off a prepared instruction inside an AI tool.

Where you'll run into it: You run into it in Claude Code, Codex CLI, the /memory, /agents, /review commands, and reusable workflows.

— Automation

Hook

A hook triggers an automatic action before or after certain moves the agent makes.

Where you'll run into it: You see it in Claude Code, to block a command, run a formatter, or check a file that just changed.

— GitHub

GitHub issue

A GitHub issue is a structured piece of work you can hand off to a person or to an agent.

Where you'll run into it: You'll run into it in backlogs, bugs, feature requests, GitHub agents, and tasks assigned to Codex or Claude.

— GitHub

GitHub Actions

GitHub Actions automatically runs tasks whenever something happens in a repo.

Where you'll run into it: You see it for tests, builds, deployments, newsletters, PR reviews, and scheduled scripts.

— Vercel

Vercel Function

A Vercel Function runs server code without you having to manage a server yourself.

Where you'll run into it: You'll run into it in /api folders, newsletter forms, webhooks, AI calls, and Vercel logs.

— Automation

Vercel Cron Job

A Vercel Cron Job runs a task at a fixed time, like a monitoring run or a data refresh.

Where you'll run into it: You see it for automatic briefs, scheduled scripts, newsletters, cache refreshes, and recurring agents.

— Supabase

Supabase Auth

Supabase Auth handles user accounts, logins, and access rights.

Where you'll run into it: You'll run into it in logins, magic links, OAuth, JWT, RLS, and projects with a user area.

— Supabase

Supabase Edge Function

A Supabase Edge Function runs server-side code to connect an app to APIs or handle a sensitive action.

Where you'll run into it: You see it in Stripe webhooks, AI calls, lightweight backend processing, and automations wired to Supabase.

— Supabase

Service role key

The service role key is a very powerful Supabase key that bypasses RLS rules and must stay server-side.

Where you'll run into it: You run into it in Edge Functions, admin scripts, private backends, and integrations that need to act outside a user session.

— No-code

n8n node

An n8n node is an automation building block that receives, transforms, or sends data.

Where you'll run into it: You see it on the n8n canvas with HTTP Request, Gmail, OpenAI, Supabase, Webhook, or AI Agent.

— No-code

n8n credentials

n8n credentials store the access to your tools so you don't have to copy your keys everywhere.

Where you'll run into it: You run into them in API, OAuth, OpenAI, Gmail, Supabase, Slack, or Google Sheets connections.

— Automation

Automation trigger

A trigger is the event that starts an automation.

Where you'll run into it: You see it in n8n, Zapier, GitHub Actions, webhooks, forms, schedules, and recurring agents.

— No-code AI

n8n AI Agent node

The n8n AI Agent node gives an automation an agent that can pick tools based on the request.

Where you'll run into it: You run into it in no-code AI workflows, Chat Trigger, n8n tools, human review, and business assistants.

— GitHub

GitHub repository

A GitHub repository is the official folder that holds a project's files, history, and settings.

Where you'll run into it: You'll see it when you connect Codex, import a project into Vercel, or follow the issues, branches, and pull requests.

— Vercel

Preview Deployment

A Preview Deployment is a live test version generated before you publish officially.

Where you'll run into it: You run into it in Vercel, GitHub pull requests, review links, and fixes before production.

— Supabase

Supabase table

A Supabase table stores data like a spreadsheet, with Postgres behind it.

Where you'll run into it: You run into it in Supabase dashboards, CRMs, leads, users, content, transactions, and agent history.

— Agent

OpenAI Agents SDK

The OpenAI Agents SDK is for building agents that can call tools, keep a work thread, and hand tasks off to other agents.

Where you'll run into it: You run into it in projects that go beyond simple chat and want to orchestrate research, tools, approvals, and real actions.

— OpenAI API

Realtime API

A Realtime API lets you exchange with a model as a continuous stream, often for voice, audio, or highly responsive interfaces.

Where you'll run into it: You see it in voice assistants, live support agents, audio apps, and experiences where waiting for a full answer would be too slow.

— Agent

Voice agent

A voice agent listens, understands, replies out loud, and can sometimes trigger actions in the middle of the conversation.

Where you'll run into it: You run into it in customer support, phone lines, personal assistants, and real-time AI demos.

— API

Batch API

A Batch API sends lots of AI requests in deferred mode to pay less or process a big volume without blocking the interface.

Where you'll run into it: You run into it to summarize thousands of articles, enrich records, sort leads, or clean up a document base.

— MCP

Remote MCP server

A remote MCP server exposes tools or data to an agent over the internet, instead of running only on your machine.

Where you'll run into it: You see it when an agent connects to GitHub, Notion, Supabase, or Slack, or a business service, without installing a local server.

— API

OpenRouter

OpenRouter gives you access to many models through a single API, making it much easier to switch providers.

Where you'll run into it: You'll run into it in prototypes that want to test OpenAI, Anthropic, Google, Mistral, or open models without rewriting the integration.

— API

Provider routing

Provider routing automatically picks which AI provider to call based on cost, latency, availability, or the model requested.

Where you'll run into it: You'll see it in AI gateways, multi-model architectures, and tools that avoid depending on a single provider.

— API

Model gateway

A model gateway is a central layer that routes AI calls, applies rules, tracks usage, and protects your keys.

Where you'll run into it: You'll run into it in stacks using Vercel AI Gateway, LiteLLM, OpenRouter, or in companies that want control over their model calls.

— API

Model fallback

Model fallback switches to another model when the first one fails, costs too much, or answers too slowly.

Where you'll run into it: You'll see it in AI products that need to stay up even when a provider is overloaded or temporarily down.

— Documents

Mistral OCR

Mistral OCR turns PDFs, images, or scanned documents into text an AI can work with.

Where you'll run into it: You run into it in workflows that read invoices, contracts, scans, tables, or document files before a RAG.

— Agent security

Agent goal hijack

An agent goal hijack happens when an external instruction pulls the agent off its original objective.

Where you'll run into it: You run into it when an agent reads a web page, an email, or a document that hides a malicious instruction.

— Agent security

Tool misuse

Tool misuse is an agent using a tool at the wrong moment, with the wrong parameters, or for an action it wasn't meant to take.

Where you'll run into it: You see it in agents that can send emails, edit files, call an API, or run a shell command.

— Security

Confused deputy

The confused deputy is a scenario where an authorized agent is tricked into doing something the attacker couldn't do directly.

Where you'll run into it: You run into it in OAuth, MCP, connected tools, and agents that act with strong permissions.

— Agent security

Memory poisoning

Memory poisoning means slipping false information into an agent's memory to sway its future decisions.

Where you'll run into it: You see it in agents with long-term memory, persistent preferences, knowledge bases, or user profiles.

— Agent security

Context poisoning

Context poisoning slips a misleading piece of data into the context given to the model to steer its answer or its actions.

Where you'll run into it: You'll run into it in RAG, web pages read by agents, emails, support tickets, and shared documents.

— Agent security

Context isolation

Context isolation separates trusted instructions, user data, and external content to avoid dangerous mixing.

Where you'll run into it: You see it in agent architectures that read the web, handle secrets, or work with several untrusted sources.

— MCP

MCP resource

An MCP resource exposes a piece of data the agent can read, such as a file, a table, a page, or an application's state.

Where you'll run into it: You run into it in MCP servers that give access to local files, databases, tickets, or business documents.

— MCP

MCP prompt

An MCP prompt is a reusable instruction exposed by an MCP server to guide an agent on a specific task.

Where you'll run into it: You see it in MCP servers that offer request templates, business routines, or prompts shared across tools.

— MCP

MCP sampling

MCP sampling lets an MCP server ask the client to call the model, under the control of the user or the app.

Where you'll run into it: You'll run into it in advanced MCP integrations where an outside tool wants to call the model without holding the model's key itself.

— Agent

Tool schema

A tool schema tells the model a tool's name, its expected parameters, and what the tool can do.

Where you'll run into it: You see it in function calling, Agents SDKs, MCP, the n8n AI Agent, and custom tools.

— Agents

Tool annotation

A tool annotation adds hints about an agent tool's behavior, risk, or intended use.

Where you'll run into it: You run into it in MCP and in systems that want to flag whether a tool reads, writes, deletes, or triggers a sensitive action.

— Agent

Prompt chaining

Prompt chaining breaks a mission into several successive prompts, each using the result of the previous one.

Where you'll run into it: You run into it in writing, extraction, verification, and scoring workflows, plus simple AI automations.

— Agent

Agentic routing

Agentic routing decides which agent, tool, or sub-process should handle a request based on its content.

Where you'll run into it: You'll see it in multi-agent assistants, customer support, curation workflows, and architectures with a specialist per task.

— Agent security

Approval gate

An approval gate blocks an action until a human approves it or an explicit rule allows it.

Where you'll run into it: You run into it before sending an email, publishing, deleting, making a payment, or changing something in production.

— Agent security

Tripwire

A tripwire is a detection rule that stops or escalates an agent when risky behavior shows up.

Where you'll run into it: You see it in guardrails, output checks, tool validations, and agents that handle sensitive actions.

— Agent

Durable execution

Durable execution lets an agentic workflow resume after a pause, an error, a restart, or a human approval.

Where you'll run into it: You run into it in LangGraph, Temporal, long-running workflows, monitoring agents, and automations that shouldn't start over from scratch.

— Observability

Tool-call audit log

A tool-call audit log keeps a record of the actions an agent requested, the parameters it sent, and the results it got back.

Where you'll run into it: You'll see it in production agents, security reviews, error investigations, and observability dashboards.

— Advanced RAG

Knowledge graph

A knowledge graph links entities together to represent who is connected to what across a corpus.

Where you'll run into it: You'll run into it in GraphRAG, advanced document search, complex business databases, and assistants that need to understand relationships.

— Data

Entity

An entity is an identifiable item in a text: a person, company, place, product, contract, date, or concept.

Where you'll run into it: You see it in information extraction, knowledge graphs, GraphRAG, and document search engines.

— Documents

Entity extraction

Entity extraction automatically spots the names, dates, organizations, amounts, or key items in a text.

Where you'll run into it: You run into it in workflows that turn emails, contracts, invoices, tickets, or articles into structured data.

— Documents

Relation extraction

Relation extraction identifies the links between entities, like who owns what, who works with whom, or which document cites which contract.

Where you'll run into it: You see it in GraphRAG, knowledge graphs, competitive monitoring, and analyses of large document corpora.

— Data

Entity linking

Entity linking ties a mention found in a text back to the right reference entity.

Where you'll run into it: You'll run into it when a system needs to understand that two name variants point to the same company, person, or product.

— RAG

Dense vector

A dense vector represents the meaning of a text with lots of numbers, nearly all of them useful for semantic comparison.

Where you'll run into it: You see it in modern embeddings, vector databases, semantic search, and RAG systems.

— RAG

Sparse vector

A sparse vector mainly represents the words or signals that are present, with lots of empty positions.

Where you'll run into it: You run into it in hybrid search, modern BM25, lexical engines, and vector databases that mix dense and sparse.

— RAG

Cosine similarity

Cosine similarity measures how much two vectors point in the same direction — in other words, how much two texts resemble each other.

Where you'll run into it: You'll see it in vector databases, embeddings, recommendation engines, and RAG result rankings.

— Advanced RAG

HNSW

HNSW is a type of index that speeds up finding nearby vectors without comparing every document one by one.

Where you'll run into it: You run into it in Qdrant, Weaviate, pgvector, vector-mode Elasticsearch, and high-volume vector databases.

— Advanced RAG

Metadata filter

A metadata filter narrows the search to certain documents based on their source, date, client, language, type, or status.

Where you'll run into it: You run into it in serious RAG systems, when the agent should only search within the right document space.

— Advanced RAG

Vector namespace

A vector namespace separates sets of embeddings so you don't mix up clients, projects, languages, or environments.

Where you'll run into it: You'll run into it in Pinecone, multi-tenant vector databases, staging/prod testing, and walled-off document assistants.

— Data

Upsert

An upsert creates a record if it doesn't exist, or updates it if it already does.

Where you'll run into it: You'll see it in Supabase, vector databases, document syncs, and pipelines that re-index content.

— RAG

Incremental indexing

Incremental indexing adds or updates only the documents that changed, instead of rebuilding the whole database.

Where you'll run into it: You'll run into it in living knowledge bases, Drive, Notion, SharePoint, websites, and production RAG.

— Advanced RAG

Chunk overlap

Chunk overlap keeps a small shared zone between two pieces of a document so an idea isn't cut off in the wrong place.

Where you'll run into it: You'll see it in RAG pipelines, LangChain loaders, LlamaIndex, and document-chunking settings.

— Advanced RAG

Parent document retriever

A parent document retriever searches within small chunks, then returns a wider passage to keep the context.

Where you'll run into it: You run into it in LangChain, documentation assistants, and RAG systems that need to avoid answers chopped up too finely.

— Advanced RAG

Contextual compression

Contextual compression trims the retrieved passages down to only the pieces useful to the question.

Where you'll run into it: You see it in RAG setups that want to save tokens, cut noise, and sharpen answer accuracy.

— Advanced RAG

Multi-query retrieval

Multi-query retrieval rephrases one question into several searches to find more relevant passages.

Where you'll run into it: You run into it in LangChain, research assistants, agentic RAG, and ambiguous questions where a single query misses documents.

— Advanced RAG

MMR

MMR picks results that are both relevant and different from each other, so you don't get ten near-identical passages.

Where you'll run into it: You see it in retrievers, vector databases, document search engines, and RAG systems that need diverse sources.

— Advanced RAG

RRF

RRF merges several search rankings to produce a more robust final list.

Where you'll run into it: You run into it in hybrid search, when a system combines BM25, vectors, reranking, or several engines.

— Advanced RAG

Cross-encoder

A cross-encoder compares a question and a passage directly to judge their relevance more precisely than a plain vector score.

Where you'll run into it: You'll see it in rerankers, advanced RAG engines, and systems where ranking quality matters more than raw speed.

— Documents

OCR

OCR turns the text inside an image or scan into text a machine can read.

Where you'll run into it: You run into it with scanned invoices, image PDFs, ID documents, paper contracts, and Document AI workflows.

— Sources

Document provenance

Document provenance tells you where a piece of information comes from: file, page, date, author, passage, or source system.

Where you'll run into it: You see it in RAG with citations, audits, legal workflows, compliance, and assistants that have to back up their answers.

— Evaluation

Faithfulness

Faithfulness measures whether an answer stays true to the sources it was given, instead of adding claims that aren't there.

Where you'll run into it: You'll run into it in RAG evaluations, Ragas, quality dashboards, and document-assistant tests.

— Evaluation

Context precision

Context precision measures whether the passages handed to the model are actually useful for answering the question.

Where you'll run into it: You see it in RAG testing, when you want to cut noise and check that the retriever surfaces the right documents.

— Evaluation

Context recall

Context recall measures whether the system actually retrieved all the passages needed to answer correctly.

Where you'll run into it: You'll run into it in RAG evaluations, especially when an answer needs several sources or several pieces of one file.

— Evaluation

Golden dataset

A golden dataset is a set of validated examples used as a benchmark to test AI prompts, models, or workflows.

Where you'll run into it: You see it when a team wants to compare two prompts, check for a regression, or measure an agent's quality before production.

— No-code

Zap

A Zap is a Zapier automation that links a trigger to one or more actions.

Where you'll run into it: You run into it when a form creates a row, sends an email, adds a lead, or notifies a team automatically.

— Make

Make scenario

A Make scenario is a visual workflow that connects modules to move and transform data.

Where you'll run into it: You see it in Make with HTTP modules, routers, filters, Google Sheets, Gmail, Supabase, or OpenAI.

— Make

Make router

A Make router splits a scenario into several branches based on conditions.

Where you'll run into it: You'll run into it when an automation needs to treat a hot lead, an error, an existing customer, or a new contact differently.

— Make

Iterator

An iterator takes a list and turns it into items processed one by one.

Where you'll run into it: You'll see it in Make, n8n, and automations that loop over rows, attachments, products, emails, or API results.

— Make

Aggregator

An aggregator groups several items processed separately back into a final list, report, or batch.

Where you'll run into it: You'll run into it after an iterator, when you need to gather results before sending an email, creating a file, or calling an API.

— No-code

Data mapping

Data mapping is about connecting a field from one tool to the right field in another.

Where you'll run into it: You run into it in n8n, Make, Zapier, forms, CRMs, and workflows that move a first name, email, status, or amount between services.

— Automation

Run / Execution

A run, or an execution, is one complete run of a workflow with its inputs, outputs, errors, and processing time.

Where you'll run into it: You'll run into it in n8n, Make, Zapier, GitHub Actions, Vercel logs, and automation dashboards.

— MCP

MCP elicitation

MCP elicitation lets an MCP server ask the user for a piece of information through the client.

Where you'll run into it: You'll run into it when a connected tool needs to ask for a detail, an approval, or a sensitive piece of data before moving on.

— MCP

MCP roots

MCP roots tell an MCP server which folders or spaces it's allowed to access.

Where you'll run into it: You'll see them in file connectors, local projects, code MCP servers, and settings that fence off the scope of access.

— MCP

MCP resource template

An MCP resource template describes a parameterized resource that the agent can open using a variable.

Where you'll run into it: You'll run into it when a server exposes files, tickets, tables, or pages through a dynamic address.

— MCP

MCP tasks

MCP tasks represent long-running operations that the client can track or resume later.

Where you'll run into it: You see them in MCP tools that launch a search, a document process, or an action that doesn't answer instantly.

— MCP security

Token passthrough

Token passthrough means relaying a user's token to another service instead of handling a proper authorization of its own.

Where you'll run into it: You see it in MCP and OAuth discussions, when a connected server risks abusing a user's access.

— Tool governance

Progressive tool discovery

Progressive tool discovery loads only the tools that are useful, instead of handing everything to the model from the start.

Where you'll run into it: You run into it in agents with lots of MCP servers, tool catalogs, or possible actions.

— Agent security

Agent credential model

The agent credential model defines whether the agent acts with its own access or the user's.

Where you'll run into it: You'll run into it the moment an agent can read data, publish, send an email, or change a connected tool.

— Orchestration

Planner / executor

Planner / executor splits the agent that builds the plan from the one that runs the steps.

Where you'll run into it: You see it in code, research, or support agents that need to think before they act.

— Orchestration

Evaluator-optimizer

Evaluator-optimizer is a loop where an output is produced, evaluated, then improved.

Where you'll run into it: You'll see it in agents that review their own work, compare several answers, or fix a generation before delivering it.

— Orchestration

Agent graph

An agent graph represents an agentic workflow as nodes, state, and transitions.

Where you'll run into it: You'll run into it in LangGraph, complex agents, and workflows that aren't just a straight line of steps.

— Vector DB

Integrated embedding

An integrated embedding is generated directly by the database or search service at index or query time.

Where you'll run into it: You see it in vector databases that simplify RAG pipelines by sparing you from managing the embedding model yourself.

— Vector DB

Payload index

A payload index speeds up filters on the fields attached to your vectors.

Where you'll run into it: You'll run into it in Qdrant, Weaviate, or RAG setups that filter by client, date, language, source, or status.

— Advanced RAG

Multivector

A multivector represents a single document with several vectors rather than just one.

Where you'll run into it: You run into it in high-precision search engines, ColBERT, late interaction, and multimodal RAG.

— Advanced RAG

Late interaction

Late interaction compares a question's and a document's vectors more finely after a first round of selection.

Where you'll run into it: You run into it in retrieval systems that want more precision than a single global vector score.

— pgvector

IVFFlat

IVFFlat is a vector index that speeds up search by grouping vectors into lists.

Where you'll run into it: You'll see it in pgvector and Postgres when a vector database needs to stay fast on larger amounts of data.

— LangChain

LangChain text splitter

A LangChain text splitter cuts documents into chunks a RAG system can actually use.

Where you'll run into it: You'll run into it in LangChain tutorials, document ingestion, chunking, and assistants that read PDFs.

— LlamaIndex

VectorStoreIndex

VectorStoreIndex is the LlamaIndex index that turns documents into a queryable vector search.

Where you'll run into it: You see it in LlamaIndex, RAG prototypes, document assistants, and pipelines that connect documents to a vector database.

— LlamaIndex

Ingestion pipeline

An ingestion pipeline chains chunking, metadata extraction, embeddings, and storage.

Where you'll run into it: You run into it when a knowledge base has to be fed on a regular basis without redoing everything by hand.

— RAG evaluation

Response groundedness

Response groundedness measures whether an answer is genuinely backed by the context it was given.

Where you'll run into it: You see it in RAG evaluations, anti-hallucination tests, and quality dashboards for document assistants.

— RAG evaluation

Noise sensitivity

Noise sensitivity measures whether a RAG stays reliable when the context contains useless or misleading passages.

Where you'll run into it: You run into it in Ragas, robustness tests, and assistants that have to hold up against imperfect documents.

— Perplexity

Sonar Perplexity

Sonar is Perplexity's family of models built to search, source, and synthesize the web.

Where you'll run into it: You see it in the Perplexity API, monitoring agents, sourced research, and workflows that want answers with citations.

— Vercel

Vercel AI SDK

The Vercel AI SDK helps you build AI interfaces, model calls, and agents inside web apps.

Where you'll run into it: You'll run into it in Next.js projects, chatbots, generative apps, response streaming, and multi-provider integrations.

— Hugging Face

Hugging Face Hub

The Hugging Face Hub is the platform where models, datasets, Spaces, and AI-related files get published.

Where you'll run into it: You see it when you're looking for an open model, a demo, a dataset, or a model card.

— Anthropic API

Messages API

The Messages API is Anthropic's entry point for sending a conversation to Claude and getting an answer back.

Where you'll run into it: You'll see it in Claude integrations, agents, API calls, streaming, and any tool that uses Anthropic.

— API

API endpoint

An API endpoint is the exact address a tool calls to request an action or fetch some data.

Where you'll run into it: You run into it in the OpenAI, Anthropic, Supabase, and Vercel docs, in webhooks, and in no-code integrations.

— API

Rate limit

A rate limit caps the number of requests or tokens an API accepts over a given period.

Where you'll run into it: You run into it when an automation runs too fast, when a provider returns a quota error, or when an agent fires off too many calls.

— AI costs

Reasoning tokens

Reasoning tokens are the ones some models burn while thinking before they produce the visible answer.

Where you'll run into it: You run into them in reasoning models, API bills, effort settings, and cost/quality comparisons.

— Models

Model card

A model card sums up a model's capabilities, limits, intended uses, and known risks.

Where you'll run into it: You'll see it on Hugging Face, in provider docs, and in serious AI model comparisons.

— Security

Data retention

Data retention tells you how long a provider keeps your prompts, files, logs, or outputs.

Where you'll run into it: You run into it in API terms, enterprise plans, privacy policies, and AI tool audits.

— Voice

Speaker diarization

Speaker diarization splits a transcript by who is speaking.

Where you'll run into it: You see it in meeting notes, podcasts, customer calls, interviews, and advanced transcription tools.

— Voice

Voice activity detection

Voice activity detection spots when a person starts or stops talking.

Where you'll run into it: You run into it in voice agents, the Realtime API, phone assistants, and low-latency audio interfaces.

— Voice

Speech-to-speech

Speech-to-speech turns spoken input into spoken output, sometimes with a different voice or a different language.

Where you'll run into it: You see it in voice agents, AI dubbing, spoken translation, voice changers, and real-time assistants.

— Voice

Voice cloning

Voice cloning recreates a voice from audio samples.

Where you'll run into it: You run into it in dubbing tools, podcasts, avatars, deepfakes, and voice consent policies.

— Image

Text to image

Text to image generates an image from a written prompt.

Where you'll run into it: You see it in Midjourney, GPT Image, DALL-E, Flux, Stable Diffusion, and visual creation tools.

— Image

Inpainting

Inpainting replaces or fixes a specific area of an image with an AI generation.

Where you'll run into it: You see it when you remove an object, change a detail, repair a photo, or edit a masked area.

— Multimodal

Multimodal embedding

A multimodal embedding represents text, image, audio, or video in one and the same vector space.

Where you'll run into it: You'll run into it in text-to-image search, product catalogs, multimodal RAG, and engines that mix several formats.

— Video

Video generation

Video generation creates or extends a video clip with a generative model.

Where you'll run into it: You see it in Sora, Veo, Runway, Pika, generated ads, social videos, and creative prototypes.

— Documents

Document Intelligence

Document Intelligence analyzes a document's text, layout, tables, fields, and structure.

Where you'll run into it: You run into it in Azure Document Intelligence, Google Document AI, Mistral OCR, invoice extraction, and document RAG.

— Security

Deepfake

A deepfake is synthetic content that imitates a real person, often in image, voice, or video.

Where you'll run into it: You'll see it in debates about voice cloning, avatars, fraud, digital identity, and content verification.

— Browser agents

Browserbase

Browserbase provides cloud browsers to run web agents, tests, and automations.

Where you'll run into it: You run into it in browser agents, controlled scraping, cloud Playwright tests, and robust web automations.

— Browser agents

Browser Use

Browser Use is a framework and cloud for getting an AI agent to carry out web tasks.

Where you'll run into it: You'll see it in automations that fill out forms, navigate sites, or read pages like a real user.

— Browser agents

Stagehand

Stagehand combines Playwright with AI instructions to automate the web with more flexible actions.

Where you'll run into it: You'll run into it in web agents that can click, read, extract, and adapt when an interface changes.

— Browser agents

Headless browser

A headless browser is a browser with no visible window, driven by code or by an agent.

Where you'll run into it: You run into it in Playwright, Puppeteer, Browserbase, automated tests, scraping, and agents that browse the web.

— Cursor

Cursor Rules

Cursor Rules are persistent instructions that frame how Cursor behaves in a project.

Where you'll run into it: You run into them in Cursor projects, coding conventions, team rules, and configs much like AGENTS.md.

— Creator tools

v0

v0 is Vercel's tool for generating interfaces, apps, and prototypes from instructions.

Where you'll run into it: You run into it in prompt-to-app workflows, quick mockups, React components, and projects tied to Vercel.

— Creator tools

Lovable

Lovable is an AI platform that generates and deploys web apps from plain-language requests.

Where you'll run into it: You run into it in AI no-code builders, SaaS prototypes, Supabase integrations, and app-building workflows that don't start from an empty repo.

— Supabase

Supabase Realtime

Supabase Realtime pushes changes or messages live to connected users.

Where you'll run into it: You see it in chats, live dashboards, collaborative apps, notifications, and generated tools that need to react without a page reload.

— No-code

n8n expression

An n8n expression drops a dynamic value or a formula into a workflow field.

Where you'll run into it: You'll see it when a workflow needs to reuse an email, a date, an ID, or a piece of data from an earlier node.

— No-code

n8n error workflow

An n8n error workflow fires when an automation fails.

Where you'll run into it: You'll run into it to alert, log, retry, or safeguard a workflow that runs unattended.

— Vercel

Deployment Protection (Vercel)

Vercel Deployment Protection controls who can access a preview or production deployment.

Where you'll run into it: You see it when an internal app, a prototype, or a preview shouldn't be publicly visible.

— AI model

The 12 basics

Before you get lost in the glossary: 12 foundational AI words explained with concrete analogies for non-dev founders. A 3-minute read.

Where you'll run into it:

— AI model

Bolt.new

Bolt.new is StackBlitz's tool that builds a real web app from a plain description, no code needed. Perfect for prototyping an idea in a few minutes.

Where you'll run into it:

— AI model

ChatGPT Atlas / Operator

ChatGPT Atlas / Operator is OpenAI's agent browser: it browses, clicks, and buys for you. Reserved for Pro and Business subscribers. My honest take inside.

Where you'll run into it:

— AI model

Choosing your model in 2026

Not a catalog, a decision tree. 6 steps to pick THE right AI model in 2026 based on your use case, your budget and your data constraints. Built for non-dev founders.

Where you'll run into it:

— AI model

Claude Haiku 4.5

Claude Haiku 4.5: Anthropic's small, fast, cheap model, perfect for classifying, extracting, and automating at high volume without blowing your budget.

Where you'll run into it:

— AI model

Claude Opus 4.7

Claude Opus 4.7 is Anthropic's most powerful model in 2026: complex code, long reasoning, autonomous agents. Pricier than Sonnet, but a game-changer.

Where you'll run into it:

— AI model

Cursor

Cursor is the AI-powered code editor devs live in in 2026, a direct rival to Claude Code. Not for non-devs, but worth knowing. Pricing, comparison, my take.

Where you'll run into it:

— AI model

DeepSeek R1

DeepSeek R1: the open-weight reasoning model from January 2025 that rattled OpenAI. Free weights, MIT license, the founding shock of open source.

Where you'll run into it:

— AI model

DeepSeek V3.2

DeepSeek V3.2 is the Chinese open-weight model with performance close to GPT-5, at 30x less on the API. The go-to when budget matters and you need scale.

Where you'll run into it:

— AI model

Flux

Flux is Black Forest Labs' family of image models: photorealistic, faithful to your prompt, with an open version. Pro, Dev, Kontext editions. Pricing and my take.

Where you'll run into it:

— AI model

Gemini 2.5 Flash

Gemini 2.5 Flash is Google's lightweight model: fast, 1M-token context, unbeatable price for crunching volume without blowing your budget.

Where you'll run into it:

— AI model

Genspark

Genspark: the all-in-one AI agent platform. Deep research, slides, docs, and an agent that makes phone calls for you. Starts at $20/month.

Where you'll run into it:

— AI model

GPT-5

GPT-5 is OpenAI's big model from mid-2025, now replaced by GPT-5.5. Still on the API, no longer the default in ChatGPT. Comparison and my honest take.

Where you'll run into it:

— AI model

Grok 4

Grok 4 is xAI's AI built into X, with real-time access to posts. The handy tool for keeping up with the news of the moment, in a more direct tone.

Where you'll run into it:

— AI model

Imagen 4

Imagen 4 is Google DeepMind's image generator: three variants, very low pricing, built into Gemini and Google Workspace.

Where you'll run into it:

— AI model

Kling

Kling is Kuaishou's video generator (China): really strong on human motion, and 3 to 4 times cheaper than Sora 2 or Veo 3. Perfect for testing at volume.

Where you'll run into it:

— AI model

Llama 4

Llama 4 is Meta's open-weight model: free to download, host it yourself, 10M-token context. The most open one, not the smartest one.

Where you'll run into it:

— AI model

Midjourney v7

Midjourney v7: the image model with the best-looking output out of the box. Three words are enough to get four gorgeous visuals. Style References, draft mode, web and Discord.

Where you'll run into it:

— AI model

Mistral Large 3

Mistral Large 3 is Mistral AI's French model, released under Apache 2.0 so it's genuinely open-source. The European sovereignty pick, and great in French.

Where you'll run into it:

— AI model

Perplexity Comet

Perplexity Comet is Perplexity's web browser with a built-in AI agent: it browses, fills out forms, and compares for you. Pricing, Atlas comparison, my take.

Where you'll run into it:

— AI model

Qwen 3

Qwen 3 is Alibaba's open-weight model in 2026: 118 languages, an open license, and strong on niche languages. The other Chinese alternative to DeepSeek.

Where you'll run into it:

— AI model

Replit Agent

Replit Agent is the AI agent that builds and deploys a real web app straight from your browser, no coding. Perfect for testing a business idea. Pricing and my take.

Where you'll run into it:

— AI model

Sora 2

Sora 2 is OpenAI's video generator: a line of text becomes a 10-to-20-second clip with sound. The easiest way to get started with AI video.

Where you'll run into it:

— AI model

Suno

Suno: the mainstream AI song generator. Describe a style, hand it lyrics or not, and it spits out a full song with vocals in a few minutes.

Where you'll run into it:

— AI model

Udio

Udio is the AI song generator from ex-Google DeepMind folks. Often more believable than Suno on vocals and mixing, with section-by-section editing.

Where you'll run into it:

— AI model

Veo 3

Veo 3, Google DeepMind's video model: a realistic clip with native sound from a text prompt or an image. Unbeatable on cinematic scenes and landscapes.

Where you'll run into it:

— AI model

Windsurf

Windsurf is Codeium's AI-powered IDE, now owned by OpenAI. For devs: chat, autocomplete, and the Cascade agent. A direct rival to Cursor.

Where you'll run into it: