The words we use for AI changed faster between 2024 and 2026 than in the decade before. Prompt engineering grew into context engineering. Chatbots became agents, and agents became teams. Words that did not exist three years ago, such as context rot, agent harness, subagent, vibe coding, and agent washing, now appear in board decks and job posts.
This glossary maps that vocabulary. It defines more than 200 terms in 13 families, gives each one a plain-English definition and a reason it matters, dates the terms that have a clear origin, and links each to a deeper article. It also traces the words AI borrowed from brain science, and rates how well each analogy holds.
TL;DR: This agentic AI glossary defines 200+ terms in 13 families, from tokens and transformers to MCP, subagents, context rot, prompt injection, and autonomy levels. Each term gets a plain-English definition, a reason it matters, and a deep-dive link. Brain-science roots, security, infrastructure, and 2026 autonomy research are included. Build with them free
What Is Agentic AI, and Why Did Its Vocabulary Change So Fast?
Agentic AI is software that takes a goal, plans the steps, uses tools, checks the result, and keeps working with limited supervision. A chatbot answers one message and waits. An agentic system finishes multi-step work: it searches, drafts, updates records, and asks for approval before anything risky. The vocabulary changed fast because the systems moved from answering to acting in under three years.
Anthropic drew the most-quoted line in the field on December 19, 2024. In Building Effective Agents, it defined workflows as "systems where LLMs and tools are orchestrated through predefined code paths" and agents as "systems where LLMs dynamically direct their own processes and tool usage." Both count as agentic AI. The difference is who decides the next step: your code, or the model. Read the full field guide in /blog/agentic-ai and the wiki entry on agentic AI.
Most of the vocabulary has a birthday. The table below dates the terms that minted the field, each with a primary source.
| Year | Term | Origin | Source |
|---|---|---|---|
| 1943 | Artificial neuron | McCulloch and Pitts, "A Logical Calculus of the Ideas Immanent in Nervous Activity" | Wikipedia |
| 1949 | Hebbian learning | Donald Hebb, The Organization of Behavior | Wikipedia |
| 1958 | Perceptron | Frank Rosenblatt, Psychological Review 65 | PubMed |
| 1960 | Confirmation bias | Peter Wason's 2-4-6 rule-discovery experiment, the classic demonstration (the label came later) | Wikipedia |
| 1972 | Episodic vs semantic memory | Endel Tulving | Wikipedia |
| 2014 | Driving automation levels 0-5 | SAE J3016, the template for agent autonomy levels | Wikipedia |
| Jun 12, 2017 | Transformer, attention | Vaswani et al., "Attention Is All You Need" | arXiv 1706.03762 |
| Jan 28, 2022 | Chain-of-thought prompting | Wei et al. | arXiv 2201.11903 |
| Oct 6, 2022 | ReAct | Yao et al., reasoning plus acting | arXiv 2210.03629 |
| Nov 25, 2024 | Model Context Protocol | Anthropic | Anthropic |
| Dec 19, 2024 | Workflow vs agent | Anthropic, Building Effective Agents | Anthropic |
| Feb 2025 | Vibe coding | Andrej Karpathy, Collins Word of the Year 2025 | Wikipedia |
| Feb 24, 2025 | Jagged intelligence (enterprise use) | Salesforce AI Research, crediting Karpathy | Salesforce |
| Mar 19, 2025 | 50% time horizon | METR | METR |
| Jun 14, 2025 | Levels of autonomy for AI agents | Feng, McDonald, and Zhang | arXiv 2506.12469 |
| Jun 25, 2025 | Agent washing | Gartner press release | Gartner |
| Jul 14, 2025 | Context rot | Chroma technical report by Hong, Troynikov, and Huber that popularized the term | Chroma |
| Sep 29, 2025 | Context engineering | Anthropic | Anthropic |
| Dec 15, 2025 | Slop | Merriam-Webster Word of the Year 2025 | Merriam-Webster |
| Feb 18, 2026 | Measured agent autonomy | Anthropic telemetry study | Anthropic |
Read left to right, the eras stack on each other. Brain science gave AI its first metaphors. Neural networks turned the metaphors into math. Transformers made language models practical. Reasoning methods taught them to plan. Agents gave them tools, and agent teams split the work.
How Do All These Terms Fit Together? The Agent Stack in One Diagram
Every agentic AI term belongs to one of six layers: model, context, tools, loop, team, and governance. The model predicts text. The context decides what the model sees. Tools let it act. The loop repeats plan, act, and check. Teams split work across agents. Governance keeps people in control. Place a new term on this stack and you know what problem it solves.
The same stack as a column, with one example term per layer and the question each layer answers:
+------------------------------------------------------------+
| GOVERNANCE human in the loop "Who can stop it?" |
+------------------------------------------------------------+
| TEAM subagents "Who does which part?" |
+------------------------------------------------------------+
| LOOP ReAct "What happens next?" |
+------------------------------------------------------------+
| TOOLS MCP "What can it touch?" |
+------------------------------------------------------------+
| CONTEXT context window "What does it know now?" |
+------------------------------------------------------------+
| MODEL LLM "How does it write?" |
+------------------------------------------------------------+
| Layer | What it answers | Example terms | Glossary family |
|---|---|---|---|
| Model | How does the system produce text? | LLM, token, transformer, GPU | 1. Foundation, 2. Reasoning, 11. Infrastructure |
| Context | What does it know right now? | context window, RAG, memory | 5. Context and memory |
| Tools | What can it change in the world? | tool calling, MCP, sandbox | 4. Tools and protocols |
| Loop | How does it decide the next step? | ReAct, planning, reflection | 3. Agents, 7. Reliability |
| Team | How is work split? | subagent, orchestration | 3. Agents, 13. Workspace |
| Governance | Who stays in control? | human in the loop, guardrails, least privilege | 6. Training, 7. Reliability, 10. Governance, 12. Human factors |
How to read this glossary. Each family opens with a one-paragraph answer, then a table: the term, a plain-English definition, why it matters, and a deep-dive link to the matching Taskade wiki article. The wiki's AI and Automation Terms page is the A to Z reference. This post is the map.
| # | Family | Table entries | Start with these three |
|---|---|---|---|
| 1 | Foundation | 28 | LLM, token, context window |
| 2 | Reasoning | 18 | Chain-of-thought, reasoning model, ReAct |
| 3 | Agents and autonomy | 29 | AI agent, subagent, human in the loop |
| 4 | Tools and protocols | 22 | Tool calling, MCP, prompt injection |
| 5 | Context and memory | 24 | Context engineering, context rot, RAG |
| 6 | Training and alignment | 14 | RLHF, alignment, sycophancy |
| 7 | Reliability and evaluation | 18 | Hallucination, evals, trace |
| 8 | Brain-inspired | 16 | Artificial neuron, working memory, connectome |
| 9 | Builder and culture | 10 | Vibe coding, agentic engineering, agent washing |
| 10 | Governance and security | 13 | Least privilege, red teaming, audit log |
| 11 | Infrastructure and cost | 15 | GPU, memory bandwidth, cost per task |
| 12 | Human factors | 5 | AI delegation, workslop, automation bias |
| 13 | Workspace (Taskade) | 17 | Workspace DNA, Taskade EVE, AI Teams |
A few terms appear in two families on purpose, for example working memory in both the memory table and the brain table. Without those repeats, the glossary still defines more than 200 distinct terms.
1. Foundation Terms: How LLMs Work
A large language model (LLM) is a neural network trained to predict the next token in a sequence, and almost every other AI term describes an input, a limit, or a side effect of that one job. Tokens are the units it reads. The context window is how many it can see at once. Temperature is how adventurous its next pick is. For the full walkthrough, read how LLMs work.
| Term | Plain-English definition | Why it matters | Deep dive |
|---|---|---|---|
| Large language model (LLM) | A neural network trained on huge amounts of text to predict what comes next | The engine inside every chatbot and agent | LLMs |
| Token | A chunk of text, often part of a word, that the model reads and writes | Limits, speed, and cost are all counted in tokens | Token |
| Tokenizer | The component that splits text into tokens | Explains odd behavior with spelling, numbers, and some languages | Tokenizer |
| Next-token prediction | The single training objective: guess the next token | Everything an LLM does emerges from this one task | Next-token prediction |
| Transformer | The 2017 architecture that processes all tokens in parallel with attention | The design behind almost every modern LLM | Transformer |
| Attention mechanism | Math that lets each token weigh every other token when computing meaning | Why models track long-range references | Attention |
| Parameters | The learned numbers (weights) inside a model | A rough measure of capacity, not of quality | Model parameters |
| Context window | The maximum number of tokens a model can consider at once | Sets how much of your project an agent can read in one turn | Context window |
| Inference | Running a trained model to get an output | Where you pay, in time and money, every day | Inference |
| Temperature | A setting for how random the next-token choice is | Low for facts, higher for brainstorming | Temperature |
| Non-determinism | The same prompt can produce different answers | Why you test agents many times, not once | Non-determinism |
| Embeddings | Lists of numbers that place text by meaning, so similar ideas sit close together | The basis of semantic search and RAG | Embeddings |
| Knowledge cutoff | The date after which the model saw no training data | Why agents need web search for recent facts | Knowledge cutoff |
| Parametric knowledge | What a model "knows" from training, stored in its weights | Useful but frozen, and hard to cite | Parametric knowledge |
| Scaling laws | Observed rules that loss falls predictably as data, compute, and size grow | Why labs keep building bigger clusters | Scaling laws |
| Mixture of experts (MoE) | A model that routes each token to a few specialist sub-networks | Large capacity at a lower cost per token | MoE |
| KV cache | Stored attention results for tokens already processed | Makes long chats and agent loops faster | KV cache |
| Tokens per second | How fast a model writes output | Decides whether an agent feels live or slow | Tokens per second |
| Prompt | The input text you give a model | The most basic control you have | Prompt |
| System prompt | Standing instructions placed before every conversation | Sets an agent's role, tone, and rules | System prompt |
| Multimodal model | A model that reads or writes images, audio, or files as well as text | Lets agents analyze screenshots, PDFs, and charts | Multimodal AI |
| Open-weight model | A model whose weights are published for anyone to run | More choice on cost, hosting, and control | Open-source models |
| Foundation model | A large model trained on broad data that many products adapt to their own tasks | One model, many apps, so its limits spread to every app built on it | LLMs |
| Generative AI | AI that creates new text, images, audio, or code instead of only sorting input | The umbrella term that LLMs and image models sit under | Generative AI |
| Small language model (SLM) | A compact model built to run cheaply or on a device, with a narrower range of skill | Many simple steps inside an agent do not need a frontier model | Model distillation |
| Quantization | Storing a model's weights with fewer bits so that it uses less memory | Cheaper, faster inference at a small cost in accuracy | Inference cost |
| Stateless model | A model that keeps nothing between requests and rebuilds its view from the text it receives | Every sense of memory comes from the software around the model | Stateless vs stateful |
| Inductive bias | The built-in assumptions that decide which answer a learner picks when many answers fit the data | Explains why design choices shape what a model learns | Inductive bias |
2. Reasoning Terms: How Models Think Before They Answer
Reasoning terms describe techniques that make a model spend more tokens working through a problem before it commits to an answer. Chain-of-thought prompting, published by Wei et al. on January 28, 2022, showed that writing out intermediate steps improves results on math and logic. Reasoning models now do this by default, and "test-time compute" names the budget they spend. See the full guide to reasoning models.
| Term | Plain-English definition | Why it matters | Deep dive |
|---|---|---|---|
| Chain-of-thought (CoT) | The model writes intermediate steps before the final answer | Big gains on multi-step problems | Chain-of-thought |
| Reasoning model | A model trained to think at length before it replies | Better at planning, math, and code | Reasoning models |
| Test-time compute | Extra computation spent while answering, not while training | A second way to buy quality besides bigger models | Test-time compute |
| Reasoning effort | A setting for how long a reasoning model thinks | Trade speed and cost for depth | Reasoning effort |
| Self-consistency | Sample several reasoning paths and take the majority answer | Cuts random errors on hard questions | Self-consistency |
| Tree of thoughts | Explore several branches of reasoning and prune the weak ones | Search instead of a single straight line | Tree of thoughts |
| ReAct | Interleave reasoning ("Thought") with tool use ("Action") and results ("Observation") | The basic loop of most agents since 2022 | ReAct pattern |
| Planning | Breaking a goal into ordered sub-steps before acting | Separates agents from one-shot chat | Planning and reasoning |
| Chain-of-thought faithfulness | Whether the written reasoning is the reasoning the model used | Visible steps are not always a true explanation | CoT faithfulness |
| Zero-shot prompting | Asking for a task with no examples | The default way most people use AI | Zero-shot learning |
| Few-shot prompting | Giving a handful of examples in the prompt | Teaches a format without training | Few-shot learning |
| In-context learning | A model picking up a pattern from examples in its context, with no weight change | Why good examples beat long instructions | In-context learning |
| Prompt chaining | Splitting a job into a sequence of prompts, each feeding the next | The simplest agentic workflow | Prompt chaining |
| Reflexion | After a failed try, the agent writes a short lesson and reads it on the next try, with no weight change | Better retries through memory, not retraining | arXiv 2303.11366 |
| Plan-and-execute | One step writes the full plan, and later steps carry it out and revise it when needed | Fewer model calls than deciding each step from scratch | Planning and reasoning |
| Scratchpad | A working area where the model writes notes and partial results before it answers | Room to work, like scrap paper | Chain-of-thought |
| Thinking budget | A cap on how many tokens a reasoning model can spend on thought before it answers | Keeps cost and wait time predictable | Test-time compute |
| Verifier | A separate check, by code or a second model, that accepts or rejects a proposed answer | Catches errors the writer model misses in its own work | LLM-as-a-judge |
Reflexion comes from Noah Shinn and co-authors, first posted to arXiv on March 20, 2023 as "Reflexion: Language Agents with Verbal Reinforcement Learning." The agent improves through written self-reflection that it keeps in memory, not through weight updates. That split between remembering and retraining runs through the whole agent vocabulary.
In Taskade you set how hard an agent thinks with thinking modes, explained in depth in AI thinking modes explained.
3. Agent and Autonomy Terms: From Chatbot to Autonomous Agent
An AI agent is a system that pursues a goal by planning, calling tools, checking results, and repeating until the goal is met, and autonomy is how many of those steps it takes without a person approving them. "AI agent", "agentic AI", and "autonomous agent" overlap, which is the most common source of confusion in the whole vocabulary. The table below separates them.
| Term | What it names | Key test |
|---|---|---|
| AI agent | One system that pursues a goal with tools | Does it choose its next step? |
| Agentic AI | The whole category of goal-directed, tool-using AI | Does any part of the system plan and act? |
| Autonomous agent | An agent set high on the autonomy dial | Does it run long stretches without approval? |
| Agentic workflow | Predefined steps with AI inside some of them | Is the path written in advance? |
| Multi-agent system | Several agents that split and hand off work | Do agents delegate to each other? |
A quick way to classify any product you meet:
Does it only reply inside a chat?
|-- yes --> CHATBOT or ASSISTANT
|-- no --> Does it call tools that change things outside the chat?
|-- no --> ASSISTANT (drafts and suggests)
|-- yes --> Is the sequence of steps written in advance?
|-- yes --> AGENTIC WORKFLOW
|-- no --> AI AGENT
|-- Does it delegate to other agents?
| |-- yes --> MULTI-AGENT SYSTEM
|-- Does it run long stretches without approval?
|-- yes --> AUTONOMOUS AGENT
| Term | Plain-English definition | Why it matters | Deep dive |
|---|---|---|---|
| Agent loop | The repeat cycle of perceive, plan, act, and check | The heartbeat of every agent | Agent loop |
| Agent harness | The code around a model that supplies tools, memory, and the loop | Two agents on the same model can differ entirely by harness | Agent harness |
| Subagent | A helper agent that a lead agent starts for one sub-task, with its own fresh context | Keeps the lead agent's context clean | Subagents |
| Orchestrator | The agent or code that plans work and assigns it to others | Anthropic's "orchestrator-workers" pattern | Orchestration |
| Agent handoff | Passing a task and its context from one agent to another | Where multi-agent systems often lose information | Agent handoff |
| Routing | Classifying an input and sending it to the right agent or model | Cheap way to get specialist quality | Routing |
| Always-on agent | An agent that keeps working after you close the chat, from schedules or events | Turns agents from tools into teammates | Autonomous agents |
| Computer-use agent | An agent that operates a screen with clicks and keystrokes | Reaches apps with no API, at a reliability cost | Computer-use agents |
| Browser agent | A computer-use agent limited to a web browser | Same trade-off, narrower scope | Computer-use agents |
| Human in the loop | A person approves or edits an agent's action before it takes effect | The main safety control for real-world actions | Human in the loop |
| Levels of autonomy | A scale for how much an agent acts without the user | A shared language for risk | Autonomous agents |
| Autonomy certificate | A proposed statement of the highest autonomy level an agent is cleared for | Governance for agent fleets | arXiv 2506.12469 |
| Time horizon | The length of task, in human time, an agent completes at a set success rate | Tracks agent progress over years | METR |
| Long-horizon agent | An agent built to work on one goal across many hours or sessions | Needs memory, checkpoints, and task ledgers | Long-horizon agents |
| Agent session | One bounded run of work that starts empty and ends when you close it | Anything not saved to memory is gone when the session ends | Agent session |
| Specialized agent | An agent built for one job, such as sales, support, or research | Depth beats one generalist doing everything thinly | Specialized agents |
| Hierarchical agents | A lead agent delegates to manager agents, which delegate to worker agents | Scales to large jobs, with more handoffs that can lose detail | Agent orchestration |
| Swarm | Many peer agents that coordinate without one fixed leader | Flexible, but harder to trace and debug | Multi-agent systems |
| Parallelization | Running independent sub-tasks at the same time and merging the results | Cuts wait time on work that splits cleanly | Parallelization |
| Stop condition | The rule that ends an agent loop: goal met, step limit reached, or budget spent | Without one, a loop can run and spend without end | Circuit breaker |
| Goal monitoring | The agent tracks progress against a measurable target and corrects drift | Keeps long runs pointed at the real goal | Goal monitoring |
| Headless agent | An agent with no chat window that runs in the background from events or schedules | Most production agents run this way | Autonomous agents |
| Human on the loop | A person watches an agent's actions and can step in, but does not approve each one | The supervision model for low-risk, high-volume work | Human in the loop |
| Agent framework | A code library that supplies the loop, tools, and memory plumbing for building agents | The developer route to agents, next to no-code builders | Agent frameworks |
The Five Levels of Agent Autonomy
Self-driving cars got a shared scale in 2014, when SAE International published the six-level J3016 standard. AI agents got theirs on June 14, 2025, when K. J. Kevin Feng, David W. McDonald, and Amy X. Zhang published Levels of Autonomy for AI Agents. Their scale is defined by what the user does, not by what the model can do.
| Level | User role | What the agent does | Everyday example |
|---|---|---|---|
| L1 | Operator | Acts only on direct instructions | "Rewrite this paragraph" |
| L2 | Collaborator | Works jointly with you, step by step | Pair-writing a plan in chat |
| L3 | Consultant | Leads the work and asks you for guidance | Drafts a campaign, asks which audience |
| L4 | Approver | Acts, and you validate key decisions | Prepares emails that wait for your Approve |
| L5 | Observer | Acts on its own while you monitor | Triages a support queue overnight |
The same paper proposes autonomy certificates, which state the highest level an agent is cleared to run at, as a way to govern single-agent and multi-agent systems.
Trust moves one way in this diagram, but in practice you step an agent back down whenever a task becomes riskier or less reversible. For how the levels play out in task management, read autonomous task management.
How autonomous are agents in real use? On February 18, 2026, Anthropic published Measuring AI Agent Autonomy in Practice, a study of Claude Code sessions. The median turn lasted about 45 seconds, but the 99.9th percentile turn grew from under 25 minutes in late September 2025 to over 45 minutes in early January 2026. Newer users (under 50 sessions) ran full auto-approve in roughly 20% of sessions, and by 750 sessions that share rose above 40%. Experienced users also interrupted more often: new users (around 10 sessions) interrupted in about 5% of turns, and more experienced users in about 9%. Only 0.8% of actions appeared irreversible, such as sending an email to a customer.
The study defines "new" slightly differently for each measure: under 50 sessions for auto-approve, and about 10 sessions for interrupts. Experienced users delegate more and step in more precisely. A second measure comes from METR, which reported on March 19, 2025 that the length of tasks frontier agents complete at 50% reliability had been doubling about every 7 months for 6 years.
The bars plot the reported bounds: under 25 minutes, then over 45 minutes.
An agent works through a multi-step task in Taskade. It plans, calls tools, and checks each result against the goal.
4. Tool and Protocol Terms: How Agents Touch the World
Tool terms describe how a model moves from writing text to changing something real, such as searching the web, creating a task, or posting to Slack. The model never runs the tool itself. It emits a structured request, the harness runs it, and the result returns as new context. Protocols such as MCP standardize that exchange so one tool works with many agents.
| Term | Plain-English definition | Why it matters | Deep dive |
|---|---|---|---|
| Tool calling | The model outputs a structured request to use a tool, and the harness runs it | How agents act instead of only talk | Tool calling |
| Function calling | The original vendor name for tool calling | Same idea, older label | Function calling |
| Structured outputs | Forcing a model's reply to match a JSON schema | Lets code rely on AI output | Structured outputs |
| Model Context Protocol (MCP) | An open standard for two-way connections between data sources and AI tools | One integration serves many AI apps | MCP |
| MCP server | A service that exposes data and actions over MCP | How a product makes itself usable by agents | MCP server |
| MCP client | The AI application that connects to MCP servers | Where the agent lives | MCP client |
| Agent-to-agent protocol (A2A) | An open protocol for agents from different vendors to find each other and exchange tasks | Agents talking to agents, not only to tools | A2A |
| Webhook | A URL that receives an event the moment it happens in another app | The real-time doorbell for automations | Webhook trigger |
| Trigger and action | A trigger starts a workflow on an event, and an action does the work | The grammar of every automation | Actions and triggers |
| Sandbox | An isolated place where an agent's code runs without reaching your real systems | Limits the damage of a bad command | Agent sandbox |
| Agent permissions | Rules for which data and tools an agent may use | Least privilege for software that acts | Agent permissions |
| Circuit breaker | A stop rule that halts an agent after repeated failures or spend | Prevents runaway loops | Circuit breaker |
| Prompt injection | Hidden instructions in content an agent reads that try to hijack it | The top security risk for agents that read the web | Prompt injection |
| Tool poisoning | A malicious tool description that steers an agent into harmful calls | Why you vet MCP servers before you connect | Tool poisoning |
| Tool schema | The name, description, and typed inputs that describe a tool to the model | A vague schema is a common cause of wrong tool calls | Tool calling |
| MCP tool | A function an MCP server exposes that the model chooses to call | Model-controlled actions, such as creating a record | MCP server |
| MCP resource | Data an MCP server offers as context, such as file contents | Application-controlled context that the client attaches | MCP |
| MCP prompt | A template an MCP server offers for the user to pick, often as a slash command | User-controlled shortcuts to a repeatable task | MCP |
| MCP transport | How MCP messages travel: stdio for a local process, or Streamable HTTP for a remote server | Decides whether a server runs on your machine or in the cloud | MCP vs API |
| Elicitation | An MCP feature that lets a server ask the user for missing input in the middle of a task | The agent can ask instead of guess | MCP client |
| Agent skills | Folders of instructions, scripts, and resources that an agent loads only when a task needs them | More know-how without a crowded context window | Agent skills |
| Excessive agency | An agent with more permissions, tools, or autonomy than its job needs | Listed as risk LLM06 in the OWASP Top 10 for LLM Applications 2025 | Agent permissions |
The MCP specification (version 2025-11-25) sorts what a server offers into three primitives by who controls them. Prompts are user-controlled, resources are application-controlled, and tools are model-controlled. The spec defines two standard transports, stdio and Streamable HTTP. Anthropic introduced Agent Skills on October 16, 2025, described them as "folders that include instructions, scripts, and resources," and published the format as an open standard on December 18, 2025.
Where these live in Taskade. Taskade connects to 100+ bidirectional integrations: triggers pull events in, and actions push data out. Agents come with built-in tools for web search, reading a web page, running code, analyzing files, generating images, and project and task actions. Taskade agents read the web. They search and fetch pages, and they never drive a browser, click, or fill in forms. A hosted MCP server lets outside AI clients reach your workspace on every paid plan, and an MCP client step in automations calls third-party MCP servers on every plan.
Point an AI assistant that speaks MCP at your hosted Taskade server, sign in once, and it can work on your projects.
5. Context and Memory Terms: What an Agent Knows
Context terms describe what sits in the model's working view on a given turn, and memory terms describe what survives between turns. Anthropic defined context engineering on September 29, 2025 as "the set of strategies for curating and maintaining the optimal set of tokens (information) during LLM inference." The same article describes context rot, a term that Chroma's July 2025 technical report popularized: as the number of tokens in the context window grows, the model's ability to recall information from it decreases. More context is not always better context.
| Term | Plain-English definition | Why it matters | Deep dive |
|---|---|---|---|
| Context engineering | Choosing what goes into the context window on each turn | The skill that replaced prompt engineering for agents | Context engineering |
| Context rot | Recall gets worse as the context window fills | Why long chats drift | Context rot |
| Context compaction | Summarizing a full context and restarting with the summary | Lets agents run past the window limit | Context compaction |
| Retrieval-augmented generation (RAG) | Fetch relevant passages and add them to the prompt before answering | Grounds answers in your documents | RAG |
| Agentic RAG | The agent decides when, what, and how often to retrieve | Better answers on messy questions | Agentic RAG |
| GraphRAG | Retrieval over a knowledge graph of entities and links, not only text chunks | Answers questions that span many documents | GraphRAG |
| Chunking | Splitting documents into passages for retrieval | Bad chunks break good retrieval | Chunking |
| Vector database | A store that finds items by embedding similarity | The index behind most RAG systems | Vector database |
| Semantic search | Search by meaning instead of exact keywords | Finds "refund policy" when you type "money back" | Semantic search |
| Knowledge graph | Facts stored as entities and the relations between them | Makes connections explicit and checkable | Knowledge graph |
| Prompt caching | Reusing the processed form of a repeated prompt prefix | Cuts cost and latency for agents that reread the same context | Prompt caching |
| Persistent memory | Information an agent keeps across chats and sessions | Stops you from repeating yourself | Persistent memory |
| Memory types | The split between working, episodic, semantic, and procedural memory | A borrowed map from cognitive science | Memory types |
| Agent knowledge | The files, links, and projects an agent is trained on | Makes a general model your specialist | Agent knowledge |
| Short-term memory | What an agent holds during the current task, mostly the context window | Clears when the session ends | Agent memory |
| Long-term memory | What an agent stores outside the model and reads back in a later session | Lets an agent recall last month's decision | Persistent memory |
| Grounding | Tying an answer to a named source, such as a document, record, or search result | Makes answers checkable and cuts hallucination | RAG |
| Knowledge base | The organized set of documents and facts an agent retrieves from | Quality in, quality out | Agent knowledge |
| Ontology | A formal model of the things in a domain and how they relate | Turns "close the deal" into one specific, checkable action | Ontology |
Agent memory borrowed its categories from psychology. Endel Tulving separated episodic memory (remembering an experience) from semantic memory (knowing a fact) in 1972. Agent builders now use the same split.
| Memory type | Brain origin | Agent equivalent | Analogy strength |
|---|---|---|---|
| Working memory | Short-term, limited-capacity store for the task at hand | The context window | Close |
| Episodic memory | Personal experiences placed in time (Tulving, 1972) | Chat history and run logs | Loose |
| Semantic memory | General facts, separate from when you learned them | Knowledge base, projects, RAG index | Close |
| Procedural memory | Skills you perform without recalling how you learned them | Skills, custom commands, saved workflows | Loose |
| Consolidation | Sleep-linked transfer from short-term to long-term storage | Summaries written to a memory file | Metaphor only |
For the deep version of this section, read AI agent memory and the context engineering field guide. The brain-science side of consolidation lives in memory consolidation.
The workspace memory knowledge graph in Taskade. Memory improves what agents know: it gives them better content to read on the next task.
6. Training and Alignment Terms: How Models Get Their Behavior
Training terms describe how a model gets its knowledge and its manners: pre-training fills it with knowledge, fine-tuning shapes it for a task, and preference tuning teaches it which answers people want. Alignment is the goal of that last stage, that the model does what its users and builders intend. The same stage produces a well-known failure, sycophancy.
| Term | Plain-English definition | Why it matters | Deep dive |
|---|---|---|---|
| Pre-training | The first, largest training run on broad text | Where general knowledge comes from | Model training |
| Fine-tuning | Further training on a narrow set of examples | Specializes a model for a task or tone | Fine-tuning |
| Reinforcement learning | Learning from rewards for good actions | The basis of RLHF and many reasoning models | Reinforcement learning |
| RLHF | Reinforcement learning from human feedback: people rank answers, and the model learns their preference | Turned raw LLMs into assistants | RLHF |
| DPO | Direct preference optimization: learn from ranked pairs without a separate reward model | Simpler, cheaper preference tuning | DPO |
| Constitutional AI | Train a model against a written set of principles, with AI feedback | Anthropic's approach to alignment at scale | Constitutional AI |
| Distillation | Train a small model to copy a large model's outputs | Fast, cheap models with much of the quality | Model distillation |
| Transfer learning | Reuse what a model learned on one task for another | Why one base model powers many products | Transfer learning |
| Alignment | Making a model pursue what its builders and users intend | The core safety problem | Alignment |
| Guardrails | Rules and filters that block unsafe inputs or outputs | A runtime safety layer | Guardrails |
| Sycophancy | Telling users what they want to hear instead of what is true | Quietly corrupts reviews and decisions | Sycophancy |
| Bias | Systematic skew in outputs, inherited from data or training | Fairness and accuracy risk | Bias |
| Reward hacking | A model finds a shortcut that scores well without doing the real task | Why metrics need audits | Reward hacking |
| Continual learning | A model that keeps updating its weights after deployment | An open research problem, not a shipped feature in most products | Continual learning |
Sycophancy gets its own deep dive in AI sycophancy explained. The short version: preference training rewards answers people like, and people like agreement.
7. Reliability and Evaluation Terms: How You Know an Agent Works
Reliability terms describe how agents fail and how you measure them: hallucinations are confident errors, evals are the tests, and jagged intelligence is the uneven skill profile that makes both necessary. Salesforce AI Research described jagged intelligence on February 24, 2025, crediting the term to Andrej Karpathy: AI systems break records on hard benchmarks while "sporadically struggling with simpler tasks that most humans find intuitive." Its SIMPLE benchmark holds 225 simple reasoning questions to measure that gap.
| Term | Plain-English definition | Why it matters | Deep dive |
|---|---|---|---|
| Hallucination | A fluent, confident answer that is false | The first thing to check in any AI output | Hallucinations |
| Evals | Repeatable tests that score a model or agent on real tasks | How you know a change helped | Evals |
| Agent evaluation | Evals for multi-step runs: did it reach the goal, at what cost | Final answers hide bad paths | Agent evaluation |
| LLM-as-a-judge | Using one model to grade another model's output | Scales evals, with its own biases | LLM-as-a-judge |
| Evaluation noise floor | The score change you see from randomness alone | Smaller gains than this are not real | Noise floor |
| Jagged intelligence | Strong on hard tasks, weak on some easy ones | You cannot infer easy skills from hard ones | Jagged intelligence |
| Reflection pattern | The agent critiques its own draft and revises | Cheap quality gain on writing and code | Reflection pattern |
| Error recovery | How an agent detects a failed step and tries another route | Separates demos from production agents | Exception handling |
| Observability | Logs and traces of every step an agent takes | You cannot fix what you cannot see | Agent observability |
| Mechanistic interpretability | Research that reverse-engineers the circuits inside a network | Explains why a model did what it did | Interpretability |
| Emergent behavior | A skill that appears at scale without being trained for directly | Surprises, good and bad | Emergent behavior |
| Benchmark | A fixed public test set used to compare models | Good for ranking models, weak at predicting your own tasks | Evals |
| Task success rate | The share of runs in which the agent reached the goal | The first number to track for any agent | Agent evaluation |
| Rubric | A written scoring guide that a person or a judge model applies to an output | Makes grades consistent and explainable | LLM-as-a-judge |
| Trace | The full record of one agent run: every model call, tool call, and result | Lets you replay what went wrong | Agent observability |
| Span | One timed step inside a trace, such as a single tool call | Shows where the time and the money went | Agent observability |
| Groundedness | Whether each claim in an answer is supported by the retrieved sources | The core quality measure for RAG | Hallucinations |
| Hallucitation | A citation or reference that the model invented | Open the source before you quote it | Hallucitations |
For building a test suite, read agent evals explained. For why models invent facts, read what are AI hallucinations.
8. Brain-Inspired Terms: What AI Borrowed From Neuroscience (and What It Did Not)
Most AI words that come from brain science are loose analogies, not models of the brain. The 1943 McCulloch-Pitts neuron was a logic gate inspired by a nerve cell. Rosenblatt's 1958 perceptron added learned weights. Modern networks learn by backpropagation, a method with no clear equivalent in biology. "Attention" in a transformer is a weighted sum, not the spotlight of human focus. Use the words, and keep the gap in mind.
| Brain term | AI term | Analogy strength | Source |
|---|---|---|---|
| Neuron | Artificial neuron (McCulloch-Pitts, 1943) | Loose: a threshold unit, not a living cell | Wikipedia |
| Hebbian plasticity | Weight updates during training | Loose: "neurons wire together if they fire together" is Löwel and Singer's 1992 phrasing of Hebb's 1949 idea | Wikipedia |
| Perception | Perceptron (Rosenblatt, 1958) | Loose | PubMed |
| Selective attention | Attention mechanism (2017) | Metaphor only | arXiv 1706.03762 |
| Working memory | Context window | Close: both are small, temporary, and fill up | Anthropic |
| Episodic and semantic memory | Chat history and knowledge base | Loose | Wikipedia |
| Connectome | Knowledge graph, workspace wiring map | Metaphor only | Wikipedia |
| Metacognition | Reflection pattern, self-critique | Loose | Metacognition |
| Confirmation bias (Wason, 1960) | Sycophancy | Close in effect, different in cause | Wikipedia |
| Cognitive offloading | Delegating tasks to agents | Close: the behavior is human, the tool is new | Cognitive offloading |
| Predictive coding | Next-token prediction | Loose: both predict the next input | Predictive coding |
| Associative memory | Hopfield network, attention retrieval | Loose | Hopfield network |
| World model | An internal simulation used to plan | Debated for LLMs | World model |
The two green nodes mark the closest analogies. The gray node is metaphor only. Three more brain terms appear often in 2026 AI writing:
| Term | Plain-English definition | Deep dive |
|---|---|---|
| Hebbian learning | Connections that are used together get stronger | Hebbian learning |
| Memory consolidation | The brain moves memories from short-term to long-term storage, often during sleep | Memory consolidation |
| Connectome | A complete wiring map of a nervous system's neurons and synapses. Olaf Sporns and Patric Hagmann introduced the term independently | Connectome |
Go deeper with the complete connectome explained, what is intelligence, and what is metacognition.
9. Builder and Culture Terms: The Words Teams Use in 2026
Builder terms describe how people work with AI, and culture terms describe how the industry talks about it. Both families changed the fastest. Andrej Karpathy coined "vibe coding" in February 2025, and Collins named it Word of the Year for 2025. On February 4, 2026, a year after the first post, Karpathy named "agentic engineering" his favorite term for the more disciplined practice: orchestrating coding agents and acting as their oversight.
| Term | Plain-English definition | Why it matters | Deep dive |
|---|---|---|---|
| Vibe coding | Building software by describing what you want and accepting what AI writes | Made software creation open to non-coders | Vibe coding |
| Agentic engineering | Building software by orchestrating AI agents and reviewing their work | The professional follow-up to vibe coding | Agentic engineering |
| Spec-driven development | Write a precise specification first, and let agents implement it | Specs become the source of truth | Spec-driven development |
| AGENTS.md | A repository file with instructions for coding agents | A shared rulebook for many agent tools | AGENTS.md |
| Prompt engineering | Crafting the wording of instructions for better output | Still useful, now one part of context engineering | Prompt engineering |
| Agentic workflow | A workflow with AI steps that plan or decide | The reliable middle ground between scripts and agents | Agentic workflows |
| Evaluator-optimizer | One model drafts, another critiques, and the loop repeats | One of Anthropic's five named workflow patterns | Agentic design patterns |
| AI slop | Low-quality AI content made in bulk. "Slop" was Merriam-Webster's 2025 Word of the Year | Quality, not volume, now earns attention | AI slop explained |
| Agent washing | Rebranding assistants, RPA, or chatbots as agents without real agentic capability | A buyer's warning label | Gartner |
| Bitter lesson | Rich Sutton's 2019 essay: general methods that scale with computation beat hand-built knowledge | Explains why labs bet on scale | Bitter lesson explained |
Citation capsule. On June 25, 2025, Gartner predicted that over 40% of agentic AI projects will be canceled by the end of 2027, because of rising costs, unclear business value, or weak risk controls. It estimated that only about 130 of the thousands of agentic AI vendors are real. It called the rebranding of existing assistants, robotic process automation (RPA), and chatbots without substantial agentic capability "agent washing." (Gartner)
10. Governance and Security Terms: Who Controls an Agent
Governance terms describe who can make an agent do what, how you prove it afterward, and which rules apply, and security terms name the ways agents get attacked. OWASP's Top 10 for LLM Applications 2025 ranks prompt injection first (LLM01) and lists excessive agency as LLM06. In the European Union, the AI Act obligations for providers of general-purpose AI models started to apply on August 2, 2025, according to the European Commission.
| Term | Plain-English definition | Why it matters | Deep dive |
|---|---|---|---|
| Agent governance | Policy, identity, permissions, and audit for AI agents | Answers "who approved this?" | Agent governance |
| Least privilege | Give an agent only the data and tools its task needs | Limits the damage of any one mistake or attack | Agent permissions |
| Audit log | A record of who or what took each action, and when | Proof for reviews, incidents, and compliance | Agent governance |
| Escalation path | The rule for when an agent hands a case to a person | Keeps hard or sensitive cases with people | Human in the loop |
| Red teaming | Attacking your own system on purpose to find failures before others do | The standard safety test before launch | AI safety and alignment |
| Jailbreak | A prompt crafted to make a model ignore its safety rules | Guardrails must hold against users, not only against content | Guardrails |
| Data and model poisoning | Corrupting training, fine-tuning, or embedding data to plant bad behavior | An attack on what the model learned, not on the prompt | OWASP LLM04 |
| System prompt leakage | An attacker gets the model to reveal its hidden instructions | Never put secrets in a system prompt | System prompt |
| OWASP Top 10 for LLMs | A ranked list of the most common security risks in LLM applications | A checklist for any team that ships agents | OWASP |
| Model card | A short report on how a model was built and tested, and where it falls short | A standard disclosure that buyers can compare | arXiv 1810.03993 |
| System card | A model card that also covers safety testing of the deployed system | Where labs report their safety test results | AI safety and alignment |
| Explainability | How well people can understand why an AI system produced an output | Needed for trust, appeals, and regulated decisions | Interpretability |
| General-purpose AI (GPAI) model | The EU AI Act's name for a model that can do a wide range of tasks and power many other systems | Provider duties in the EU apply from August 2, 2025 | European Commission |
Model cards come from Margaret Mitchell and co-authors, who proposed them in "Model Cards for Model Reporting," first posted on October 5, 2018. The controls stack up in the order a request travels:
No single layer stops every attack. Input filters miss some injected instructions, so the later layers, least privilege and human approval, limit what a successful attack can do. For the attack side, read prompt injection and tool poisoning.
11. Infrastructure and Cost Terms: What Runs Under the Model
Infrastructure terms explain why AI answers cost what they cost and arrive as fast as they do. A model answers in two phases. Prefill reads your whole prompt in one parallel pass. Decode then writes the reply one token at a time. Decode is usually limited by memory bandwidth, not arithmetic, because each new token requires reading the model's weights out of memory. For the full tour, read how AI data centers work.
| Term | Plain-English definition | Why it matters | Deep dive |
|---|---|---|---|
| GPU | A parallel processor, first built for graphics, that runs most AI training and inference | The unit of AI compute that labs count and buy | GPU |
| TPU | Google's custom chip, designed for neural network math | The main alternative to GPUs at cloud scale | TPU |
| HBM | High-bandwidth memory stacked beside the processor on the same package | How much a chip has decides how many users it can serve | HBM |
| Memory bandwidth | How fast data moves between memory and the compute cores | The real ceiling on how fast tokens arrive | Memory bandwidth |
| NVLink (interconnect) | NVIDIA's high-speed link that lets many GPUs share data as one machine | Large models span many chips, so link speed sets system speed | NVLink |
| AI data center | A building of accelerators, power, and cooling built to train and serve models | Power and cooling now limit AI growth as much as chips do | Data center |
| Liquid cooling | Cooling chips with liquid instead of air | Dense AI racks make more heat than air can remove | Liquid cooling |
| Prefill | The phase in which the model reads the whole prompt in one parallel pass | Long prompts cost time here, before the first word | Inference |
| Decode | The phase in which the model writes the reply one token at a time | Sets how fast the answer streams | Tokens per second |
| Time to first token (TTFT) | The wait between sending a prompt and seeing the first word | What users feel as "is it thinking?" | Inference |
| Latency | The total time one request takes | Agents chain many calls, so latency adds up | Inference |
| Throughput | How many tokens or requests a system handles per second | Decides the cost per user at scale | Tokens per second |
| Batch inference | Running many requests together, when you can wait for the results | Cuts cost for work that needs no instant answer | Inference cost |
| Inference cost | The price of one request, billed per input token and per output token | The recurring cost of every AI product | Inference cost |
| Cost per task | Total spend to finish one job, including retries and every tool call | The unit that matters more than the price per token | Inference cost |
NVIDIA H100 accelerators, with NVLink connectors along the top edge. Photo: Wikimedia Commons / 极客湾Geekerwan / CC BY 3.0
12. Human-Factor Terms: What Changes for the People Who Delegate
Human-factor terms describe what happens to people when agents join the team: how we delegate, how we review, and where our attention goes. In September 2025, researchers at BetterUp Labs and the Stanford Social Media Lab introduced "workslop" in Harvard Business Review: AI-generated work that "masquerades as good work" and shifts the effort to the person who receives it.
| Term | Plain-English definition | Why it matters | Deep dive |
|---|---|---|---|
| AI delegation | Deciding which work to hand to AI, how much authority it gets, and how you check the result | The first skill of working with agents | AI delegation |
| Workslop | AI output that looks finished but lacks the substance to move the task forward | The receiver pays for the sender's shortcut | Workslop |
| Automation bias | The habit of trusting an automated system's output even when other information says it is wrong | "A human reviews it" is not enough on its own | Automation bias |
| Attention residue | Part of your mind stays on the last task after you switch (Sophie Leroy, 2009) | Supervising many agents multiplies your switches | Attention residue |
| Digital labor | AI agents counted as a workforce that does tasks next to people | How vendors now frame and price agent work | Salesforce |
The four human-factor terms describe one chain. Poor delegation produces workslop. Automation bias lets workslop pass review. Attention residue makes the review worse as the number of agents you supervise grows. The fix sits at the start of the chain: a clear goal, a defined output, and a check that is easy to run.
13. Workspace Terms: The Taskade Vocabulary
Taskade's vocabulary maps the agent stack onto one workspace: Memory holds what your team knows, Intelligence reads it and decides, and Execution acts on it. Together they form Workspace DNA. Taskade Genesis turns a plain-English prompt into a live app built on that loop, and Taskade EVE is the agent inside Taskade Genesis that runs the build.
| Term | Plain-English definition | Where it lives | Learn more |
|---|---|---|---|
| Workspace DNA | Memory + Intelligence + Execution, the loop behind every workspace | Every Taskade workspace | Workspace DNA |
| Memory | Projects and databases that hold the facts your team works from | Projects, in multiple project views | The DNA pillars |
| Intelligence | AI agents, Taskade EVE, and frontier models from top AI labs | Agents tab, chat | Intelligence |
| Execution | Automations that move work between the tools you already run | Automations | Integration orchestration |
| Taskade EVE | The agent that plans and builds Taskade Genesis apps, asks clarifying questions, and shows its work | Taskade Genesis | Taskade EVE |
| Taskade Genesis | Prompt-to-app building: dashboards, portals, CRMs, trackers, and forms | /create | First app |
| AI Teams | Several agents that work on one prompt | Agents | AI Teams |
| Auto mode | Taskade picks the most suitable agent or agents for the prompt | AI Teams | Agent team action |
| Everyone mode | Every agent on the team responds | AI Teams | Agent team action |
| Manual mode | You pick one or more agents on the team to reply | AI Teams chat only | AI Teams |
| Orchestrate mode | The team plans the work and runs it step by step, handing each step to an agent | AI Teams | Agent team action |
| Plan & Execute | The mode in which an agent sets sub-goals, picks tools, and iterates toward a goal | Agent chat | Autonomous agents |
| Manual Approval | A per-tool setting that makes the agent wait for Approve or Reject | Agent Tools tab | Agent tools |
| TASKS.md ledger | One running task list per app workspace that Taskade EVE keeps up to date | projects/memory |
Taskade EVE memory |
| Workspace memory | Notes Taskade EVE saves as real, readable projects you can open, edit, or delete | projects/memory |
Taskade EVE memory |
| Custom commands | Saved slash commands that run a repeatable agent task | Agent settings | Custom agents |
| Community Gallery | Published apps you can open, and clone when the creator shares them as a kit | /apps | Community Gallery |
Access is role-based from Owner to Viewer. App sign-in works on every plan, Free included. Sign-in confirms who a visitor is. Row scoping is a separate, opt-in setting: you match records to each login, and you test it with a second account.
Orchestrate mode builds a plan step by step and hands each step to the best-suited agent on the team.
Which AI Terms Will Last, and Which Are Fading?
The terms that last name a durable problem, and the terms that fade name a single technique or a marketing wave. "Context window" will last as long as models have limits. "Prompt engineering" now sits inside context engineering, because agents run many turns. The table only lists shifts with a public source. Everything else is too early to call.
| Term | Status in 2026 | Replaced by, or why | Source |
|---|---|---|---|
| Prompt engineering | Absorbed | Context engineering, the wider job of curating every token an agent sees | Anthropic, Sep 2025 |
| Chatbot | Narrowed | "Agent" for systems that act, with agent washing as the caution | Gartner, Jun 2025 |
| Function calling | Renamed | Tool calling, and MCP for shared tools | Anthropic, Nov 2024 |
| Vibe coding | Split | Vibe coding for casual building, agentic engineering for professional work | Wikipedia |
| Workflow vs agent | Lasting | The core design choice in every agentic system | Anthropic, Dec 2024 |
| Levels of autonomy | Growing | A shared risk language, modeled on driving levels | arXiv 2506.12469 |
| Context rot | Growing | Names a measurable limit of long contexts | Chroma, Jul 2025 |
| Agent skills | Growing | Know-how packaged as folders an agent loads on demand, now an open standard | Anthropic, Oct 2025 |
| Workslop | Growing | Names the hidden cost of AI output that nobody checked | HBR, Sep 2025 |
How Does the Agentic AI Vocabulary Map to Workspace DNA?
Every family in this glossary lands on one of three pillars of Workspace DNA: Memory, Intelligence, or Execution. Context and memory terms describe Memory. Reasoning and agent terms describe Intelligence. Tool, protocol, and automation terms describe Execution. Governance and human-factor terms wrap all three, because they decide who can act and who checks the result. In Taskade, the three pillars are projects, agents, and automations in one workspace.
| Glossary family | Workspace DNA pillar | Ring on /connect/dna | Where it lives in Taskade |
|---|---|---|---|
| 5. Context and memory | Memory | Association (mid ring) | Projects, agent knowledge, workspace memory |
| 2. Reasoning, 3. Agents | Intelligence | Limbic (inner ring) | AI agents, AI Teams, Taskade EVE |
| 4. Tools and protocols | Execution | Cortical (outer rim) | Automations, 100+ bidirectional integrations, MCP |
| 13. Workspace terms | All three | Thalamic (core) | Workspace DNA, the loop itself |
| 10. Governance, 12. Human factors | Around all three | Not drawn as a ring | Manual Approval, role-based access from Owner to Viewer |
The /connect/dna page draws this loop as a wiring map called the connectome, with four rings read from the outside in:
+------------------------------------------------------------+
| CORTICAL (outer rim) |
| integrations, MCP, webhooks, HTTP APIs |
| +--------------------------------------------------------+ |
| | ASSOCIATION (mid ring) | |
| | projects, app kits, shared context | |
| | +----------------------------------------------------+ | |
| | | LIMBIC (inner ring) | | |
| | | agents and Taskade EVE decide, pick the tool | | |
| | | +------------------------------------------------+ | | |
| | | | THALAMIC (core) | | | |
| | | | Memory + Intelligence + Execution meet | | | |
| | | +------------------------------------------------+ | | |
| | +----------------------------------------------------+ | |
| +--------------------------------------------------------+ |
+------------------------------------------------------------+
The page turns the map into four steps:
- Connect your tools.
- Point them at a project.
- Give an agent that project as context and a job.
- Let automations run the job and write the result back.
The ring names are brain words used as a metaphor, the same way section 8 rates attention and memory. Taskade does not model a brain, and nothing in it learns on its own. Agents remember by reading your notes and projects, so the workspace gets sharper the more you use it. See the connectome map.
The Memory, Intelligence, and Execution loop. Each pillar feeds the next, and Execution writes results back into Memory.
How Taskade Genesis Puts This Vocabulary to Work
Taskade Genesis puts most of this glossary into one workspace: projects are the memory, agents and Taskade EVE are the intelligence, and automations are the execution. You describe what you need in plain English. Taskade EVE plans the app, connects the projects that hold its data, adds the agents that reason over that data, and wires the automations that act on it. The app publishes to the web and can run on a custom domain on Business and above.
Here is the glossary turned into a build path. Each step uses a term you just learned.
| Step | Term you just learned | Where it lives in Taskade | Learn link |
|---|---|---|---|
| 1. Create an agent | AI agent, system prompt | Agents tab, or ask Taskade EVE | Custom agents |
| 2. Give it knowledge | RAG, semantic memory | Files, links, projects, and media | Knowledge |
| 3. Add tools | Tool calling, MCP | Built-in tools and connected apps. An automation can call an MCP server through the MCP Client action | Agent tools |
| 4. Form a team | Multi-agent system, orchestration | AI Teams in Auto, Everyone, Manual, or Orchestrate mode | AI Teams |
| 5. Schedule it | Always-on agent, trigger | A scheduled automation | Schedule |
| 6. Add approval | Human in the loop, L4 Approver | Manual Approval on sensitive tools | Autonomous agents |
| 7. Ship it as an app | Agentic workflow, vibe coding | Taskade Genesis, published to the web | First app |
In automations, the Ask Agent Team action sends a prompt to one of your AI Teams in Auto, Everyone, or Orchestrate mode. Manual mode is for team chat only. The team's reply comes back as output that later steps can use, for example to post a summary to Slack or add tasks to a project.
An AI Team runs inside an automation. The team's reply becomes input for the next step.
Taskade Genesis builds a working app from one prompt.
You can start on the Free plan, which includes 2 workspace members, 1 agent, and 3 Taskade Genesis apps. Pro is $10/mo billed annually for teams of up to 10. Compare plans on the pricing page, explore ready-made agents at /agents and workflows at /automate, or browse live AI apps in the Community Gallery.
Frequently Asked Questions About Agentic AI Terms
What are the most important agentic AI terms to know in 2026?
Start with ten: AI agent, agentic workflow, tool calling, Model Context Protocol (MCP), context engineering, context rot, retrieval-augmented generation (RAG), human in the loop, levels of autonomy, and evals. Together they cover what an agent is, how it acts, what it knows, who stays in control, and how you test it. This glossary defines more than 200 terms in 13 families around them.
What is agentic AI in simple terms?
Agentic AI is software that takes a goal, plans the steps, uses tools such as search, code, and connected apps, checks the result, and keeps going with limited supervision. A chatbot answers one message at a time. An agentic system finishes multi-step work and can pause for your approval before a sensitive action.
What is the difference between an AI agent and agentic AI?
An AI agent is one system that pursues a goal with tools. Agentic AI is the wider category: any software that plans and acts with some autonomy, including single agents, teams of agents, and workflows that contain an agent step. Every AI agent is agentic, but agentic AI also covers multi-agent systems and agent-driven workflows.
What is the difference between an AI agent and an autonomous agent?
Autonomy is a dial, not a type. An AI agent can run at any level, from drafting suggestions that you approve to acting and reporting afterward. An autonomous agent is an agent set toward the high end of that dial: it chooses its own sub-goals and tools and runs long stretches without a person approving each step.
What are the levels of AI agent autonomy?
Feng, McDonald, and Zhang (2025) define five levels by the role of the user: operator, collaborator, consultant, approver, and observer. At level 1 the user directs each action. At level 5 the user only monitors. They also propose autonomy certificates, which state the highest level an agent is cleared to run at.
What does human in the loop mean for AI agents?
Human in the loop means a person reviews or approves an agent's action before it takes effect, for example before an email is sent or a record is changed. In Taskade you set approval per tool: Manual Approval makes the agent wait for you to click Approve or Reject, and Automatic Approval lets it act.
What is the difference between context engineering and prompt engineering?
Prompt engineering is writing a good instruction. Context engineering, as Anthropic defined it in September 2025, is curating and maintaining the optimal set of tokens during inference: the instructions plus tools, retrieved documents, memory, and message history. Agents run many turns, so what fills the context window matters more than one well-written prompt.
What is MCP (Model Context Protocol)?
MCP is an open standard that Anthropic announced on November 25, 2024 for two-way connections between data sources and AI tools. Developers expose data and actions through MCP servers, and AI applications connect to them as MCP clients. Taskade offers a hosted MCP server on every paid plan and an MCP client step in automations on every plan.
What is prompt injection?
Prompt injection is an attack that hides instructions inside content an AI reads, such as a web page, email, or document, so that the model follows the attacker instead of you. OWASP ranks it first (LLM01) in its Top 10 for LLM Applications 2025. The main defenses are least privilege, human approval before sensitive actions, and treating fetched content as data, not as commands.
What is RAG in AI?
RAG, or retrieval-augmented generation, fetches relevant passages from a knowledge source at question time and places them in the model's context before it answers. It grounds answers in your documents without retraining the model. Agentic RAG lets the agent decide when to search, what to search for, and whether the results are good enough.
What is jagged intelligence?
Jagged intelligence, a term credited to Andrej Karpathy, describes AI that breaks records on hard benchmarks yet fails simple tasks most people find easy. Salesforce AI Research described it in February 2025 and released SIMPLE, a set of 225 simple reasoning questions, to measure the gap.
What is AI sycophancy?
AI sycophancy is a model telling you what you want to hear instead of what is true: agreeing with a wrong claim, praising weak work, or changing a correct answer after you push back. It is a side effect of training on human approval, and it echoes confirmation bias in people. Read the full breakdown in AI sycophancy explained.
What is workslop?
Workslop is AI-generated work that looks polished but lacks the substance to move a task forward, so the person who receives it has to interpret, fix, or redo it. Researchers at BetterUp Labs and the Stanford Social Media Lab introduced the term in Harvard Business Review in September 2025. Clear delegation and an easy check at handoff prevent it.
Are neural networks really like the brain?
Only loosely. The 1943 McCulloch-Pitts neuron and the 1958 perceptron were inspired by biological neurons, but modern networks learn by backpropagation, not by the local rules neurons use. Terms such as attention and memory are useful analogies, not models of the brain. This glossary rates each analogy as close, loose, or metaphor only.
What does Workspace DNA mean in Taskade?
Workspace DNA is the loop behind every Taskade workspace: Memory, Intelligence, and Execution. Projects and databases hold the facts (Memory). AI agents and Taskade EVE read that memory and decide (Intelligence). Automations act across 100+ bidirectional integrations and write results back into projects (Execution), so the workspace gets sharper the more you use it.
Put the Vocabulary to Work
A glossary is a map, and a map is only useful when you travel. Every family in this post, from tokens to autonomy levels, points at something you can build today: an agent trained on your knowledge, a team that splits the work, an automation that runs on a schedule, and an app that ships it all to the people who need it. Memory, Intelligence, Execution. ▲ ■ ●
Build your first agentic app free with Taskade Genesis, or see the loop drawn as a wiring map at /connect/dna.
Related reading: