Alok Sharan's LinkedIn post (12 Nov 2026) is a one-page glossary of 20 agent terms with a small diagram per term. It is a good first map for newcomers, but about a third of its one-liners are loose enough to mislead, and it leaves out the harness ideas (context management, permissions, tracing, idempotency) that decide whether an agent works in production. Use it as a vocabulary warm-up, then correct and extend it.
The 20 terms
The post groups the terms into five sets. The middle column paraphrases the post and its tile captions; the right column is the definition a staff engineer would want a learner to leave with. Rows marked * are corrected in the next section.
| # | Term | The post's gist | Sharper definition |
|---|---|---|---|
| 1 | AI agent | An LLM in a loop that uses tools until the goal is done | A loop where the model picks the next action from the current context, and code outside the model runs it and feeds back the result. The loop, its stop condition and its budget are the design, not the model. |
| 2 | Tool calling | The model emits a structured call; your code runs it | Same. Add: the tool schema is a prompt, the arguments are untrusted input, and every call needs a permission decision. |
| 3 | ReAct | Thought, action, observation, repeat | The 2022 prompting pattern that interleaves reasoning text with tool calls. Native tool use in current models made it the default loop, so it is now more history than technique. |
| 4 | Planner | Breaks a goal into ordered steps before acting | Either an explicit plan the loop executes (plan-and-execute) or a plan the model keeps and revises. Plans go stale; the useful question is when to re-plan. |
| 5* | Reflection | The agent critiques and fixes its own draft | Self-critique without new information helps little and can make answers worse. It works when the critique has an external signal: a test run, a linter, a checker, a second model with a rubric. |
| 6 | Agent memory | Short-term in the context window, long-term in a store | Right split. Add: what gets written, when it is recalled, and how stale or wrong memories are corrected are the hard parts. |
| 7 | Agentic RAG | The agent decides when and what to retrieve | Retrieval as a tool the agent calls, often with several queries and a judgement of whether the results suffice. Coding agents often use grep and file reads instead of a vector index. |
| 8 | State | The shared object every step reads and updates | The full record needed to resume or audit a run: messages, plan, tool results, pending approvals. Distinct from memory, which outlives the run. |
| 9 | Router | Classifies a request and sends it down a path | Same. A router is usually a small classifier or a cheap model call, and often the place to use code instead of an LLM. |
| 10* | Orchestrator | A lead agent splits work and delegates to workers | One pattern among several. Orchestration can also be plain code (a workflow) that calls models at fixed steps, which is often the better choice. |
| 11* | Multi-agent system | Specialist agents collaborate, each with a role | Several model loops with separate contexts. The real benefit is context isolation and parallelism, not personas; the cost is tokens and coordination failures. |
| 12 | Handoff | One agent passes control and full context to another | Transfer of the conversation to another agent's instructions and tools. Passing the full context is a choice; a summary or a structured brief is often better. |
| 13 | Checkpointer | Saves state after each step so a crash can resume | Same. Resuming safely also needs idempotent or deduplicated side effects, or a resumed step repeats an email or a payment. |
| 14 | Human-in-the-loop | The agent pauses for approval on risky actions | Same. Design questions: which actions gate, how the approver sees enough to judge, and what happens while nobody answers. |
| 15* | Guardrail | Checks inputs and outputs and blocks unsafe content | Input and output filters are one layer. The stronger guardrails are on actions: tool permissions, scopes, rate and spend limits, and allowlists. |
| 16 | Prompt injection | Hidden instructions in a page, email or file hijack the agent | Right, and the most important row on the page. No filter reliably stops it, so the defence is limiting what an agent that has read untrusted content can do. |
| 17 | Sandbox | Agent code runs in an isolated box with no host access | Same. The tile says no network; real sandboxes often need some network, so egress control (an allowlist proxy) is the usual design. |
| 18* | MCP | One standard plug between AI apps and tools or data | An open protocol where servers expose tools, resources and prompts to a client. It standardizes the connection, not the trust: a server is code you run or a remote you rely on. |
| 19 | A2A | Agents from different vendors discover and talk to each other | An open protocol for agent-to-agent tasks, with an Agent Card that lists skills and an endpoint. MCP connects an agent to tools; A2A connects agents to agents. |
| 20* | Agent evals | Score outcome and steps on test tasks before shipping | Outcome, trajectory, tool use and cost, measured on a fixed task set and re-run on every change. The post's scorecard is right; the missing part is that evals are continuous, not a ship gate. |
Where the post is loose
Six one-liners teach a habit that causes trouble later. Fix these before handing the page to learners.
Reflection implies the model can check itself. Research on self-correction finds little gain, and sometimes loss, when the model re-reads its own answer with no new evidence. Teach reflection as "critique against a signal": run the tests, then revise.
Orchestrator and multi-agent are presented as the mature design. The list moves from single agent to orchestrator to multi-agent as if that were a progression. In practice most production systems are workflows (code calls the model at fixed steps) or a single agent with subagents for isolated side tasks. Teach "start with the simplest loop that works" and make multi-agent earn its token cost.
Multi-agent is framed as roles. The Researcher, Writer, Coder and Critic tile suggests personas are the point. The engineering value is separate context windows: each worker sees only what it needs, and the parent sees only a summary.
Guardrails are drawn as content filters. The shield tile blocks PII, toxic and off-topic text. That misses the guardrails that stop real incidents: least-privilege tools, scoped credentials, spend limits and egress rules.
MCP reads as plug-and-play. "One standard plug" hides that every MCP server is a trust decision. A tool description can carry an injection, and a server can be swapped or updated under you.
Evals sit last, as a ship gate. Placing evals at #20 under "before you ship" teaches them as a final exam. They are the regression suite you run on every prompt, model or tool change.
Two smaller points. ReAct (#3) is shown as a current technique; it is the ancestor of native tool use. The sandbox tile says "no network", which most real agents cannot live with, so the lesson is controlled egress rather than none.
What the list leaves out
The 20 terms describe the parts of an agent. They say little about the harness that keeps those parts working, which is where most engineering time goes. Add these eight to make it a course vocabulary.
| Term | Why a learner needs it |
|---|---|
| Context engineering | Choosing what goes into the window each turn. Most agent failures are context failures, not model failures. |
| Compaction | Summarizing or dropping old turns as the window fills. Long runs depend on it, and it silently loses facts. |
| Subagent | A child loop with a fresh context for one side task, returning a summary. The practical form of multi-agent. |
| Skills | Instructions and scripts loaded only when a task needs them, so the base prompt stays small. |
| Permissions and approval modes | Which tools run without asking. This is the main safety control, more than any output filter. |
| Tracing and observability | A record of every model call, tool call and token count. Without it you cannot debug or build evals. |
| Idempotency | Making side effects safe to repeat. Retries and checkpoint resumes break without it. |
| Workflow vs agent | The choice between code-driven steps and model-driven steps. Most tasks with a known shape should be workflows. |
The post also has no failure modes. A useful companion slide pairs each group with its typical failure: loops that never stop, wrong tool arguments, stale memory, lost context at handoff, double side effects on resume, approval fatigue, injected instructions, and evals that pass while users fail.
How to teach with it
The infographic works best as a map learners fill in, not a page they memorize. A 90-minute session for engineers new to agents:
Warm-up (10 min). Show the grid with the captions hidden. Learners guess each term from its small diagram, then compare with the caption.
Build the loop (25 min). Write a 30-line agent: one model call, two tools, a step limit. Point at terms 1, 2, 3 and 8 in the code as they appear.
Break it (20 min). Give the agent a web page that contains an injected instruction (#16). Learners watch it obey, then add a permission check on the dangerous tool (#14, #15) and see that a content filter alone does not stop it.
Resume it (15 min). Kill the run mid-task and restart from a checkpoint (#13). The tool that sends a message fires twice. Fix it with an idempotency key.
Measure it (15 min). Write five test tasks and score outcome, tool choice, steps and cost (#20). Change the prompt and re-run.
Correct the map (5 min). Hand out the six corrections and eight missing terms above. Ask which terms they used today and which they never needed.
Other uses:
Interview screen. Ask a candidate to explain the difference between memory and state, or MCP and A2A, and when not to use multi-agent. The post's one-liners are the shallow answer; the right column above is the strong one.
Team onboarding. Pair the page with R006 (six harness terms) and R022 (a reading list) as week-one material.
Critique exercise. Give senior learners the original post and ask them to find what it gets wrong. The six items above are the answer key.
Caution for reuse: the image is the author's work and the post ends in a book promotion. Link to the post rather than copying the graphic into slides, or redraw the grid in your own words.
Related entries
| Entry | How it connects |
|---|---|
| R006 Six must-know harness terms | The harness-side glossary this one lacks; teach them together. |
| R022 Six-stage AI engineering reading list | The reading to assign after the vocabulary session. |
| R023 Coding agent from scratch course | A full build of terms 1 to 20 in code; source for the lab steps. |
| R014 MIT Intro to AI mini-course | The user-literacy level below this one. |
| R015 Deterministic workflows | Evidence for correction 2: workflows before agents. |
| R019 s3 agent swarms | Multi-agent coordination done seriously, for terms 10 to 12. |
| R020 The model proposes, the harness enforces | Reflection with an external signal (correction 1). |
| R030 OpenShell sandboxes | Sandbox and guardrails as enforced policy, terms 15 and 17. |
| R034 AG-UI | The third protocol next to MCP and A2A: agent to user interface. |
| R035 Durable execution | Checkpointing, resume and idempotency in depth, term 13. |
| R029 Synthetic enterprise tenants for evals | Evals at scale, term 20. |
| R054 Source-code study of eleven coding agents | How real harnesses implement these terms. |
Sources
Alok Sharan, "20 Agentic AI Terms, Decoded!", LinkedIn, 12 Nov 2026.
The post's only links go to the author's book, System Design and Behavioral Intelligence, on Amazon.
The corrections draw on the related entries above and on general knowledge of the self-correction and agent-security literature.