English for AI Agents Engineers: The Vocabulary You Need

If you’re building LLM-powered agents — or interviewing at companies that do — you need more than Python skills. You need to be able to talk about agents precisely in English: in design reviews, pull request discussions, incident post-mortems, and job interviews.

This guide covers the vocabulary that comes up most often when teams discuss agentic systems. Each term includes how it’s used in real engineering conversations.

The Agent Loop

The foundational concept in any agentic system is the agent loop — the cycle of reasoning and action that an agent runs until it completes its task or hits a stopping condition.

In design discussions you’ll hear:

“The agent runs its loop until the stopping condition is met — in this case, max_steps or a tool call returning ‘task complete’.”

“We saw the agent get stuck in a tight loop — it kept calling the same tool with the same arguments. We need a stuck-loop detector that counts repeated identical tool calls.”

The most common loop architecture today is ReAct (Reasoning + Acting). An agent using the ReAct pattern:

1. Reasons about what to do next (produces a “thought” in its scratchpad)
2. Acts by calling a tool
3. Observes the tool result
4. Repeats until done

The full record of thoughts, actions, and observations in a single run is called the trajectory.

Tool Use and Function Calling

Most modern agents interact with the world through tool calling (also called function calling). The agent doesn’t execute code directly — it produces a structured output that the framework interprets as a tool invocation.

Key vocabulary:

• Tool schema — the JSON definition of a tool: its name, description, and parameters. The agent sees the schema in its context and uses it to know what tools exist and how to call them.

• Tool call — the agent’s request to invoke a tool: {"tool": "search_web", "args": {"query": "current weather London"}}

• Tool result — the response returned to the agent after the tool executes.

• Tool registry — the collection of all tools available to an agent or agent system.

In code reviews, you’ll encounter discussions like:

“The tool description is ambiguous — send_email and draft_email both appear in the registry, but the agent keeps choosing the wrong one. We need to sharpen the descriptions so the agent can distinguish when each should be used.”

This is called tool description engineering — and it’s a real, important craft.

Multi-Agent Orchestration

Complex tasks are increasingly handled not by a single agent but by a multi-agent system. In architecture reviews:

• Orchestrator agent — the top-level agent that decomposes the task, delegates subtasks to sub-agents, and aggregates results.

• Sub-agent / worker agent — a specialised agent responsible for one part of the problem. A coding agent might delegate “write the test” to a test-writing sub-agent.

• Crew — a team of agents working together (this term is popularised by frameworks like CrewAI).

• Agent handoff / delegation — passing control and context from one agent to another.

Watch for context loss in handoffs:

“After the handoff, the receiving agent doesn’t seem to know what was decided in the first three steps. We need to define what context gets serialised and passed.”

Agentic Patterns

Four patterns come up constantly in agent architecture discussions:

Planner-executor: A planner agent generates a high-level plan; an executor agent carries it out step by step. The two roles can be the same model or different models optimised for each task.

Reflection loop (also called self-refinement): The agent reviews its own output and improves it before returning a final result. In code reviews: “The agent now runs a reflection step before committing its changes — if the linter fails, it revises.”

Memory architecture: Three memory types that come up in design discussions:

• In-context memory — text currently in the agent’s context window
• Episodic memory — retrievable records of past agent runs (usually stored via vector search)
• Semantic memory — general facts and knowledge stored in a knowledge base or retrieval store

RAG in the agent loop (Retrieval-Augmented Generation): The agent queries a vector store at each reasoning step to ground its responses in retrieved documents. You’ll hear: “The agent uses RAG to fetch relevant documentation before writing the code.”

Observability

When agents are in production, observability is non-negotiable. The vocabulary:

• Trace — the full record of an agent run from start to finish: every step, tool call, and reasoning step.
• Span — a single unit of work within a trace (one tool call, one LLM call, one reasoning step).
• Token budget — the maximum number of tokens an agent is allowed to consume per run (a hard or soft limit).

Tools like LangSmith and LangFuse are designed for agent observability — they let you inspect individual spans, see which tool calls were made, and measure token consumption at each step.

In incident reviews: “The runaway agent consumed 2 million tokens in 4 hours. We need span-level token analysis in LangSmith to see which reasoning step was looping.”

Guardrails

Guardrails are the safety layer around an agent system:

• Input guardrails — checks that run on the user input before it reaches the agent (detect prompt injection, PII, off-topic requests).
• Output guardrails — checks that run on the agent’s response before it is returned or acted on (detect harmful content, hallucinated claims, sensitive data in output).
• Human-in-the-loop (HITL) — a pattern where the agent pauses and requests human approval before executing a high-risk action (irreversible API call, sending an email, deploying code).

In design reviews: “The guardrail stack should run input checks first, then the agent, then output checks. The HITL step is only triggered if the planned action involves an external write.”

Useful Phrases for Discussions

In architecture reviews and code discussions, these phrasings will serve you well:

Practice These Concepts

If you want to test your knowledge of these terms in context, the AI Agents Language exercises on CoderLingo cover:

• Agent loop and ReAct pattern
• Tool calling and function calling vocabulary
• Multi-agent orchestration
• Agent observability (traces, spans, token budgets)
• Agent guardrails
• Agentic patterns (planner-executor, reflection, memory, RAG)

Each exercise set has 5 questions with detailed explanations — designed for engineers who already know the concepts in their native language and need to learn the English vocabulary to discuss them confidently.