What Is an Agent?

"Agent" gets defined in several ways. Some people mean fully autonomous systems that operate independently for long periods. Others mean more prescriptive implementations that follow predefined workflows. Anthropic, who have worked with dozens of teams building LLM agents, draw one architectural distinction that cuts through the noise. (source)

They group everything under agentic systems, then split it:

Workflows are systems where LLMs and tools are orchestrated through predefined code paths.
Agents are systems where LLMs dynamically direct their own processes and tool usage, maintaining control over how they accomplish tasks.

That distinction is the foundation of this entire course. Get it wrong and you'll reach for an autonomous agent when a five-line workflow would have done.

The building block underneath both: the augmented LLM

Before either workflows or agents, there's a more basic unit — the augmented LLM: a model enhanced with retrieval, tools, and memory.

        ┌─────────────────────────────────┐
        │           LLM (core)            │
        └────────────┬────────────────────┘
                     │
        ┌────────────┼────────────┐
        ▼            ▼            ▼
   ┌─────────┐ ┌─────────┐ ┌──────────┐
   │Retrieval│ │  Tools  │ │  Memory  │
   └─────────┘ └─────────┘ └──────────┘

Modern models don't passively wait for these — they actively use them: generating their own search queries, selecting appropriate tools, deciding what to retain.

Anthropic's advice on the augmented LLM is specific: tailor these capabilities to your use case and give them a well-documented interface. One way to wire them in is the Model Context Protocol (MCP), which lets you integrate a growing ecosystem of third-party tools with a simple client implementation.

Workflow vs agent, in one test

Ask yourself: can you write down the path?

If you can enumerate the steps in advance (do A, then B, branch on C) → that's a workflow. Write it as code. It'll be predictable and debuggable.
If the steps depend on what the model finds along the way, and you can't predict them → that's an agent. Give it tools and a stopping condition, and let it loop.

Most 'agent' ideas are actually workflows

Before building an agent, try to write the procedure as a fixed sequence of LLM calls. If you can, you've got a workflow — and workflows are cheaper, faster, and far easier to debug than agents. Reserve the word "agent" for the cases where the path genuinely can't be written down.

Where this leads

This course starts at the augmented LLM and climbs one rung at a time:

Module 1 (this + next chapter): what agents are, and when you should and shouldn't build them.
Module 2: the workflow patterns — chaining, routing, parallelization, orchestrator-workers.
Module 3: designing the tools that make any of this work (the agent-computer interface).

By the end you'll know exactly which pattern fits your problem — and you'll be ready for the next course, where workflows become autonomous loops.

Next: When (and When Not) to Build Agents — the most expensive mistake is reaching for an agent you didn't need.