DEV Community

Cover image for 20 Agentic AI Terms Every Developer Should Know
Mohamed El Laithy
Mohamed El Laithy

Posted on

20 Agentic AI Terms Every Developer Should Know

#webdev #programming #ai #beginners

20 Agentic AI Terms Every Developer Should Know

TL;DR: Agent frameworks come with a vocabulary problem, not a complexity problem. Here are 20 terms, explained in plain language, each with a code-flavored example. Bookmark it — you'll be back.

The list, if you just want the names

  1. AI Agent
  2. Agentic Workflow
  3. Agent Loop
  4. Tool Calling
  5. Agent Harness
  6. Context Engineering
  7. Memory
  8. MCP
  9. Planning
  10. Reasoning
  11. Multi-Agent Systems
  12. Orchestration
  13. Handoff
  14. A2A
  15. Guardrails
  16. Human-in-the-Loop (HITL)
  17. Evals
  18. Computer Use
  19. Agentic RAG
  20. Agent Washing

Now the actual explanations.

1. AI Agent

An LLM that's allowed to take actions and decide what to do next, instead of replying once and stopping.

User: "Check why signups dropped yesterday."

Agent -> queries analytics DB
Agent -> checks yesterday's deploy log
Agent -> explains the drop, with evidence
Enter fullscreen mode Exit fullscreen mode

A single reply, however smart, is not an agent. The willingness to go find out is the whole point.

2. Agentic Workflow

A workflow runs fixed steps in a fixed order, even if an LLM handles one of them. An agent decides its own next step as it goes.

# workflow: same order, every time
def handle_ticket(t):
    summarize(t)
    categorize(t)
    assign(t)

# agent: decides at runtime
# - categorize? ask a question? escalate first?
Enter fullscreen mode Exit fullscreen mode

Same building blocks. Very different amount of control you're handing over.

3. Agent Loop

The cycle underneath every agent:

Decide -> Act -> Observe -> Decide -> ...
Enter fullscreen mode Exit fullscreen mode

Decide: call checkInventory(). Act: makes the call. Observe: out of stock. Decide again: call notifySupplier() instead. Repeats until the goal is met, or the agent gives up.

4. Tool Calling

The model requests a function call. Your application executes it and returns the result. The model proposes, the application disposes.

Agent -> requests getFailedPayments()
App   -> executes it, returns rows
Agent -> reads the result, explains it
Enter fullscreen mode Exit fullscreen mode

5. Agent Harness

The LLM is the brain. The harness is everything else that makes it work: tools, state, context, permissions, execution, error handling.

API call times out -> harness catches it, decides to retry, feeds the result back. The model never sees a raw exception. No harness, no agent — just a chatbot with opinions.

6. Context Engineering

Deciding what the model sees at each step, not writing one perfect prompt.

step_1..29: full history? // no
context = summarize(steps_1_28)
        + relevant_chunk(query)
        + step_29
Enter fullscreen mode Exit fullscreen mode

7. Memory

Short-term: within one chat, it remembers you already tried restarting the app. Long-term: across sessions, it recalls you always ask in a specific language.

8. MCP

A standardized way for an AI app to plug into external tools and data.

Agent <-> MCP <-> Tools / Data
Enter fullscreen mode Exit fullscreen mode

Instead of hand-coding a Postgres client and a Jira client separately, your agent talks to both through MCP servers, the same way.

9. Planning

Breaking a goal into steps before, or while, acting.

"ship this hotfix" ->
  run tests -> build -> deploy staging -> notify team
Enter fullscreen mode Exit fullscreen mode

10. Reasoning

Working through why before acting. Three near-identical tools exist (refundPayment, voidPayment, reversePayment) — reasoning is what picks the right one before any call happens.

11. Multi-Agent Systems

Split the work across specialized agents instead of one generalist trying to do it all.

Coder agent    -> writes the diff
Reviewer agent -> checks the diff
Test agent     -> runs the suite, reports back
Enter fullscreen mode Exit fullscreen mode

12. Orchestration

The layer deciding which agent runs when, and what data passes between them. It doesn't solve the task — it routes it.

ticket = classify(incoming)
if ticket.type == "billing":
    route(billing_agent, ticket)
else:
    route(technical_agent, ticket)
Enter fullscreen mode Exit fullscreen mode

13. Handoff

One agent passing control and context to another, mid-task, so the user never repeats themselves.

14. A2A

Agent2Agent — a protocol for agents to talk to other agents, even ones built by a different team.

MCP -> Agent <-> Tools
A2A -> Agent <-> Agent
Enter fullscreen mode Exit fullscreen mode

Don't mix these up. It's the single most common confusion in this list.

15. Guardrails

Automated rules that limit what an agent can do. Checked before execution, every time, no human required.

agent proposes: DROP TABLE users;
guardrail: only SELECT allowed -> blocked
Enter fullscreen mode Exit fullscreen mode

16. Human-in-the-Loop (HITL)

A human has to approve an action before it happens. Not the same as a guardrail:

  • Guardrails = automated, no person involved
  • HITL = a person approves or blocks the action 
agent.draft(refund, amount=2000)
status: PENDING_APPROVAL
-> waits for support_lead.approve()
Enter fullscreen mode Exit fullscreen mode

17. Evals

Not just "was the final answer right." Also: tool selection, execution steps, task completion, reliability across runs.

eval.check(
  called_in_order = ["getOrderStatus", "issueRefund"],
  consistent_over = 50
)
Enter fullscreen mode Exit fullscreen mode

18. Computer Use

The agent operates a UI directly — clicking, typing, reading screenshots — for the systems that never got an API.

screenshot = capture_screen()
button = locate(screenshot, "Approve")
click(button)
Enter fullscreen mode Exit fullscreen mode

19. Agentic RAG

Traditional RAG: Retrieve -> Generate. Agentic RAG turns that into a loop:

Decide what to retrieve -> Retrieve -> Evaluate -> Retrieve again -> Generate
Enter fullscreen mode Exit fullscreen mode 
results = search(query)
if not good_enough(results):
    query = rewrite(query)
    results = search(query)
answer = generate(results)
Enter fullscreen mode Exit fullscreen mode

20. Agent Washing

Calling something an "AI agent" when it's really just:

Prompt -> LLM -> Response
Enter fullscreen mode Exit fullscreen mode

No loop. No tools. No autonomy. If there's no loop, no tools, and no autonomy — it's not an agent. It's a well-dressed prompt template.

That's 20. Which one did you have wrong until embarrassingly recently? Mine was Agentic RAG — I called it "RAG with extra steps" for way too long, which, in fairness, is also correct.

If you want more practical Java, Spring Boot, backend engineering, and AI content, I post regularly — and I've got deeper notes and templates at mellaithy.gumroad.com.

Top comments (0)