# 9. Agent architecture & internals

> A model in a loop, with tools, state and a reason to stop.

Track: Agents. 31 terms.

An agent is not a special kind of model. It is ordinary software that calls a model in a loop: build the context, ask the model what to do, run the tool it asks for, add the result to the context, and repeat until the model gives an answer or a limit is hit.

Everything interesting lives in the harness around that loop: which instructions and tools the model sees, how state is stored, when to hand work to a sub-agent, and how to stop. The same model can look brilliant or useless depending on that scaffolding.

**Interactive figure on the web page: The agent loop.** An agent booking a meeting. Each lap the runtime assembles context, the model decides, a tool runs, and its result goes back into context. On the last lap the model answers instead of calling a tool and the loop ends. Step through it or let it play.

## Terms

### AI agents

Systems where an LLM decides which actions to take, calls tools, looks at the results and repeats until a goal is reached, instead of answering once.

### Agentic systems

Software in which LLM decisions steer part of the control flow, from a single tool-calling loop to large multi-agent workflows.

### Agent systems engineering

The discipline of making agents dependable in production: runtimes, state, tools, evaluation, security and cost control.

### Agent architecture

How an agent is put together: its model, instructions, tools, memory, control loop and any sub-agents or workflow graph around it.

### Agent runtime

The software that executes agents: it runs the loop, calls the model, dispatches tools, saves state and enforces limits.

### Agent harness

The scaffolding that turns a model into an agent: prompt assembly, tool definitions, output parsing, the loop and its stop rules. The same model can perform very differently in different harnesses.

### Agent control loop

The central cycle: assemble context, call the model, run any requested tools and append their results, then repeat until the model answers or a limit is reached.

### Reasoning loop

The model's think, act, observe pattern inside the control loop, popularised as ReAct, where intermediate reasoning guides the next action.

### Agent orchestration

Coordinating agents, tools and steps: what runs when, in which order or in parallel, and how results flow between them.

### Tool-calling loop

The control loop built on function calling: the model emits tool calls, the runtime runs them and returns the results as messages.

See: [related](https://llm-atlas-7or.pages.dev/learn/tool-calling/)

### Agent state machines

Modelling an agent as explicit states and transitions, such as planning, acting, awaiting approval and done, which makes behaviour predictable and recovery easier.

### Agent lifecycle

The stages of one agent instance: created, configured, running, paused or waiting for input, completed or failed, and cleaned up.

### Agent sessions

A bounded run or conversation with its own message history, state and resources.

### Agent identity

Who the agent is to other systems: its credentials, permissions and audit identity, kept separate from the user it acts for.

### Agent configuration

The settings that define an agent: model, sampling settings, instructions, enabled tools, limits and memory options.

### Agent instructions

The system prompt and guidelines that set the agent's role, goals, constraints and rules for using tools.

### Agent capabilities

What an agent can actually do. It is set by the tools and permissions it is given, not by the model alone.

### Agent state

Everything needed to continue an agent from where it is: messages, intermediate results, its plan, counters and pending tool calls.

### Tool selection

The model choosing which tool to call, or whether to call one at all, from the tool descriptions and the current context.

### Tool invocation

Actually calling the chosen tool with the arguments the model produced.

### Tool result handling

Formatting a tool's output, or its error, back into the context, often trimming or summarising large results first.

### Tool dispatch

Routing a tool call to its implementation, whether a local function, an MCP server, an HTTP API or a sandboxed process, possibly several in parallel.

### Agent termination

Ending the loop: the model gives a final answer, a step, cost or time limit is hit, an error cannot be recovered, or a person stops it.

### Subagents

Agents started by another agent for a sub-task. Each gets its own context window and returns only a summary, which keeps the parent's context small.

### Agent delegation

Handing a task to another agent, including deciding what context to pass along and what result to expect back.

### Multi-agent systems

Systems of several agents with distinct roles that cooperate, such as a planner with workers or a writer with a reviewer.

### Multi-agent collaboration

Agents working toward a shared goal by dividing the work, sharing results and checking each other.

### Agent coordination

The mechanisms that keep several agents consistent: shared state, locks, turn-taking or a supervising agent.

### Agent-to-agent communication

Messages exchanged between agents, directly or through shared memory, increasingly over standard protocols such as A2A.

### Task decomposition

Breaking a goal into smaller steps or sub-tasks that can be run, delegated or parallelised.

### Autonomous task execution

An agent carrying a task through many steps without human input, inside guardrails and limits.

Web page: https://llm-atlas-7or.pages.dev/learn/agents/

_Definitions written for LLM Atlas._