Okay, and that's the framework we're going to live in. So here's an agent, that's a picture

I'm going to use quite a lot. Here's an agent, it has actuators, things it can use to act

on the environment, and we have sensors that basically give us this perception stream.

I am going to, even though that's unrealistic, think of the environment to be external of

the agent. Of course it's going to be important that the agent is part of the environment

and that it actually thinks about itself and so on. It's still going to use this picture

because it's easier to draw. So we have the environment which we think of as being separate

from the agent, even though realistically there has to be some kind of self-awareness

to do intelligence well, just like we are self-aware. Whereas a bacterium or so is not,

we think. Probably flies and so on are also not self-aware. So you can do survival in

the wild without actually being self-aware, but I just want to mention that typically

the agent should be part of the environment. And we did a little bit more math. What is

the percept? What's the agent function? The only real problem here is that the agent function

– we've actually solved the problem of AI by this. Case closed. Mathematically it's

just a function. There are lots of functions around. There are some good functions we call

rational and there are some others that we would think of as non-rational. We can define

what that means with a little bit of math work. Solved. The problem is that if we want

to implement such a function, mathematically a function is just a long list of input-output

pairs. Typically infinitely long because we have for every perception sequence, which

can be infinitely or any size, we have to give a value, the next best action. That is

not something we can realistically implement. And the only problem in AI is to build programs

that in this situation can actually compute without looking up this infinitely long table.

And that's what we want to do for the rest of this course. You looked at the vacuum cleaner

agent and the important thing is here to always realise we have the vacuum cleaner agent and

we have an environment together. They form something that's worth talking about. And

now the question of course is how can we actually find the right agent function? And the AI

question is can we actually build this in terms of an agent architecture and a program,

which is much harder than finding the right agent function?

So here's the problem, here's the solution for this very simple agent. It's what we will

call a simple reflex agent that solves that problem, behaves well. But of course for more

difficult agents we don't know what to do best. We can always have a generic algorithm,

which is kind of a table driven algorithm, which just says somebody has determined this

function, written it down in a long table, we'll just do whatever is necessary. The problem

is of course we have more than an exponential blow up, which is not something we can actually

realistically implement.