Agent Architecture

Following on from our introduction to agents it’s important to understand the architecture of agents.

Abstract Architecture

Environment

We assume the environment may be in any of a finate set of discrete, instantaneous states, defined as:

E = {e,e^,,...}.

Actions

Agents are assumed to have a repertoire of possible actions:

Ac = {α,α^,,...}.

Run

A run of an agent in an environment is a sequence of interleaved environment states and actions:

α₀ α₁ α₂ α_n r : e₀ -> e₁ -> e₂ -> ... -> e_n

State Transformer

Let R be the set of all possible finate sequences over E and Ac.

Let R^Ac be the subset of these that end in an action.

Le R^E be the supset of these that end with an environment state.

A state transformer function represents behaviour of the environment:

t : R^Ac -> 2^E

If t(r) = the empty set, then there are no possible successor states to r and the system has ended its run.

Agent

An agent is a function that maps runs into actions:

Ag: R^E -> Ac

An agent makes a decision about what to perform based on the history of the system that it has witnessed to date.

Perception

An agent can determine atrributes of the environment through sensors.

The see function is the agent’s ability to observe its environment, whereas the action function is the agent’s decision making process.

The output of the see function is a percept:

see : Per* -> Ac

Also, action is now a function, it maps sequences of percepts to actions:

action : Per* -> Ac

Reactive Agents

Reactive agents decide what to do without reference to history. They base their decision making entirely on the present. They have actions corrosponding to particular percepts, and perform them when they sense them.

Agents with State

Some agents maintain state. They have an internal data structure used to record information about the environment state.

Let I be the set of internal states of the agent. The agent function action is now defined as a mapping from internal states to actions:

action : I -> Ac

An additional function, next, is also introduced to map an internal state and a percept to another internal state:

next : I x Per -> I

Agent Control Loop

Agent starts in some initial internal state i₀
Observes it’s environment state e, and generates a percept see(e)
Internal state of the agent is then updated via next function, becoming next(i₀, see(e))
The action selected by the agent is action(next(i₀, see(e)))
Goto 2