What Is an Agent?

The Core Distinction

An automation follows a fixed path. A new email arrives, a rule moves it to a folder. A timer fires, a script sends a report. There is no thinking, no adapting — just a trigger and a pre-programmed response. If the input changes, the automation does not care. It runs the same steps regardless.

An agent is a system that runs a continuous loop: perceive → decide → act → learn. It observes its environment, reasons about what it sees, takes real actions, and updates its understanding based on the outcome. If the input changes, the agent changes its behavior. This is the fundamental difference.

Automation vs. Agent — Side by Side

Watch both systems run. The automation fires once and stops. The agent loops continuously, adapting to what it finds.

The Agent Loop in Detail

Every agent — from a simple chatbot to a fleet of autonomous systems — runs some version of this four-stage loop:

What This Looks Like in Code

Here is a simplified agent loop in Python. Even the most complex agent systems — LangChain, CrewAI, Anthropic's Claude Agent SDK — are built on this pattern:

class SimpleAgent:
    def __init__(self, name, goal, tools):
        self.name = name
        self.goal = goal
        self.tools = tools
        self.memory = []     # what the agent remembers

    def perceive(self, environment):
        """Read the current state of the world."""
        return environment.get_current_state()

    def decide(self, observation):
        """Choose an action based on goal + observation + memory."""
        context = {"goal": self.goal, "observation": observation, "memory": self.memory}
        return self.reason(context)   # could be an LLM call

    def act(self, action):
        """Execute the chosen action using available tools."""
        tool = self.tools[action.tool_name]
        return tool.execute(action.params)

    def learn(self, action, result):
        """Update memory based on outcome."""
        self.memory.append({"action": action, "result": result})

    def run(self, environment):
        """The agent loop — runs until the goal is met."""
        while not self.goal_met():
            observation = self.perceive(environment)
            action = self.decide(observation)
            result = self.act(action)
            self.learn(action, result)

Notice the while not self.goal_met() loop — this is the heartbeat. An automation would run once and exit. The agent keeps going until its goal is satisfied.

Real-World Examples

Agents are already everywhere — you just might not have recognized them as such:

When Agents Go Wrong

Agents are powerful, but they fail in predictable ways. Understanding failure modes now prevents disasters later:

Frameworks You Should Know

You do not need a framework to build agents — the loop above is enough to start. But these tools make production agents easier:

This course teaches the concepts behind all of these. Once you understand the agent loop, memory, communication, and orchestration — you can use any framework.

The Agent Lifecycle

Agents are not permanent. They are born, they run, and they eventually terminate. Understanding the lifecycle helps you design agents that start cleanly, operate reliably, and shut down gracefully:

Agents vs. Pipelines vs. Workflows

These three terms are often confused. Here is the precise distinction:

The key test: if you can draw the entire execution path before the system runs, it is a pipeline or workflow. If the execution path depends on what the system discovers at runtime, it is an agent.