Unlike a single LLM call (RAG, chains, or a function), an agent owns its control loop. It decides what to do next at each step - which tool to call, whether to re-plan, and when the task is complete. The LLM is not writing text; it is making decisions that have real-world effects.

The critical distinction is who owns the control flow. In a chatbot, the user drives every turn. In automation, a script drives a fixed sequence. In an agent, the LLM drives dynamically - selecting tools, re-planning on failure, and deciding when the goal is met.

The perception layer assembles the context window for the next LLM forward pass: user message, prior tool results, memory retrievals, system prompt, and environment state. Everything the model will reason over comes from here.

The LLM processes the full context window and outputs a decision: a tool call (structured JSON), a final answer, or an intermediate reasoning step. Strategies like ReAct (Reason + Act interleaved), chain-of-thought prompting, or scratchpad reasoning all happen in this step.

Planning strategies range from Plan-and-Execute (full upfront decomposition, a separate planner LLM) to ReAct (one step at a time, plan embedded in the reasoning trace) to Reflexion (retry with lessons learned from failures). The right strategy depends on task uncertainty.

The agent emits a tool call; the orchestration runtime executes it in a sandboxed environment and returns the result as a tool_result message. The result is appended to the context window and becomes input to the next Perceive step.

A common architecture mistake: LLM + vector store = agent. It doesn't. The LLM can retrieve context, but it has no execution capability. A functioning agent requires all four layers orchestrated together - and swapping in a smarter model without the surrounding system produces a smarter chatbot, not an agent.

The agent monitors output quality against its success criteria and can trigger a re-plan. This is distinct from Reflexion (explicit retry with memory of failure) - reflection can be built into the reasoning prompt or implemented as an evaluation step before committing an action.

Multi-party interaction includes human-agent turns, agent-agent messaging (in multi-agent systems), and tool call/result cycles. The agent manages context state across all of these simultaneously within its context window.

Reactive behavior: the agent responds to user input or tool results. Proactive behavior: the agent detects a missing precondition mid-task and resolves it autonomously rather than failing (e.g., requesting a missing credential before a tool call would fail). Both require state tracking across the task loop.

Autonomy level determines the interrupt frequency: Copilot (every step requires human acceptance), Assistant (interrupt at pre-defined decision gates), Autonomous (interrupt only at task start/end or on error). The orchestration layer implements the interrupt conditions.

The perception layer normalizes multiple input modalities into a unified context representation:

• Text → tokenization → token embeddings
• Images → vision encoder → patch embeddings appended to context
• Audio → spectrogram encoder → sequence embeddings
• Structured data → schema-aware serialization → text representation

All modalities converge into the context window before the LLM forward pass. The agent's "state" is the assembled context at the start of each loop iteration.

Autonomy level determines the system's error recovery strategy and oversight requirements. Copilot: human-in-the-loop at every step (zero autonomous actions). Assistant: interrupt conditions defined at design time (e.g., "pause before sending any external communication"). Autonomous: interrupt only on unrecoverable error or task completion - requires robust guardrails, sandboxing, and output validation at every step.

The intelligence emerges from composing five mechanisms:

1. Tool use - Grounding via external function calls prevents hallucination on factual queries; the model knows the boundary of its parametric knowledge.
2. Multi-step reasoning - The agent decomposes complex goals into a sequence of tool calls and reasoning steps, maintaining task state across the entire sequence.
3. Self-correction - Output validation (schema checks, semantic evaluation) can trigger re-planning; Reflexion explicitly stores failure observations and conditions the retry.
4. Memory - In-context window for working state; external vector/KV stores for facts and episode recall that exceed the context limit.
5. Goal orientation - The system prompt and task description anchor every reasoning step; the agent re-checks against the original goal before committing to each action.