What is an agent?

Simon Willison is fond of asking the question "What is an agent?". There appear to be many possible definitions of what an agent is. Does this make the term useless?

Agents in general

Russell and Norvig (R&N) define an agent as "anything that can be viewed as perceiving its environment through sensors and acting upon that environment through effectors". This definition is intentionally broad, R&N were attempting to define AI as a field of study and viewed it as synonymous with the study of agents.

R&N also go on to define goal-directed agents, which are agents that are given goals to work towards rather than procedures for performing a task. Prompting with LLMs is almost always goal-directed, we specify to the LLM what we want it to do, not how to do it.

This kind of definition isn't really helpful unless you are specifically looking a catch-all term.

Environments

The one important takeaway from the R&N definition is that agents are defined in terms of their environment. LLM agents may have quite trivial environments, a simple chatbot can be considered an agent, but the only means the agent has of affecting its environment is through text responses to a human, and similarly the only feedback it receives is from the human responses.

The key to having useful agents is in providing rich environments to the agents. It's well worth listening to Shunyu Yao on the latent.space podcast where among other things he discusses the importance of thinking about the agentic environment.

Agentic Systems

Another term du jour is agentic. I really like this term as a relative adjective, a software system can be more or less agentic. In that vein, Harrison Chase (Founder of LangChain etc.) made the suggestion "The more agentic an application is, the more an LLM decides the control flow of the application" in response to Simon's tweet.

This term is useful when thinking about implementations of an LLM-based system. For a given task, there is usually a spectrum of possible implementations. At one end are heavily engineered systems where the LLM is used for small fixed tasks (as a function). At the other end are fully agentic systems where the LLM is equipped with an environment that allows for completely goal-directed task completion.

For instance, Retrieval-Augmented Generation (RAG) can be broadly split into non-agentic RAG where the retrieval is performed by software and then provided to the LLM as context, and agentic-RAG where the LLM is provided with tools and performs its own retrieval.

I recommend Travis Fisher's blog post on the Agentic Spectrum for more on the idea of agentic as a relative term.

Agentic Loop

A term that I have been using is the agentic loop. This is any loop of the form Act (on the environment) -> Feedback (from the environment) -> (Re)Act. The standard tool-usage loop is an example of an agentic loop.

Libraries like LangGraph are designed to make implementing agentic loops easier.

Composition of Agents

Let me present my current working definition of an Agent

An agent is a software component that composes like an agent

Although it appears circular, this definition is interesting to me because it defines an agent in terms of how it looks from the outside, rather than the definition of "agentic" which is defined in terms of how the system is implemented.

First, let's step back and consider what "composition" means. In this context, we're just referring to the process where a (software) system is built from smaller components. This happens at all scales, from the composition of functions to make new functions, up to the Internet itself which is an extremely complex composition of many different components.

At the smallest scale, it's interesting to think about how agentic building blocks can be composed. The easiest thing to do is to treat an LLM call like a function. We know how to compose functions, and we can easily compose LLM-based functions with ordinary software functions so this is a productive mode of development and has been the dominant mode in these early years of the LLM-era. The presence of agentic loops doesn't fundamentally change this mode of composition, we can wrap the agentic parts of the system so that they appear to the rest of the system as a function.

However, there are more agentic methods of composition. For instance, we can compose conversational agents by simply allowing them to talk to each other. This brings a very different range of patterns than software developers are used to, often with ideas from how humans are composed to work towards goals - teams, supervisors, specialists etc.

We can also think about the composition of larger agentic systems. Anthropic's MCP provides a good example of this. The Claude desktop agent can now interface with other agentic software, for example Cursor. We could imagine a scenario where I'm using the composer agent in Cursor, and I need to give the Cursor agent some info I read in a blog post that I bookmarked. Perhaps the Cursor agent could communicate with Claude, which may in turn invoke a Google Chrome agent that can search my bookmarks, and in a goal-directed manner they co-operate to perform the task.

A final thing to think about in agentic composition is that through LLMs' code-writing abilities it is possible for LLMs to build their own glue code to facilitate integration with other systems/agents. A great example of this (and perhaps my favourite paper of the year) is the Agora Protocol which demonstrates how agents can dynamically negotiate protocols between agents which bypass LLM calls completely.

Conclusion

While Agent may be a redundant term when it comes to defining software systems, it is a useful term when thinking about how software systems can be linked together. We're moving toward a future where agents won't just be isolated components but participants in a rich ecosystem of interacting systems, and we'll need to develop new vocabulary, patterns, and ideas to describe and build this future.