So we have AgentOrientedProgramming
Aside from deep philosophical debates about different capabilities and prospects for the future, what makes an agent different from an object? Is it in fact just an object with an event loop?
software somehow different from just plain DistributedSoftware?
An agent can be a person, a machine, a piece of software, or a variety of other things. The basic dictionary definition of agent is one who acts.
However, for developing IT systems, such a definition is too general: IT-related SoftwareAgent
s need additional properties. Some of the properties that agents may possess in various combinations include these PropertiesOfAgents
An industry-standard definition of agent has not yet emerged. Most agree that agents bound for IT systems are not useful without at least the first three PropertiesOfAgents
(Autonomous, Interactive, Adaptive). Others require IT agents to possess all of the properties listed above to varying degrees.
At a minimum
an agent (sometimes called an "adaptive agent") is generally regarded to be an autonomous entity that can interact with its environment. In other words, it must be able to perceive its environment through sensors and act upon its environment with effectors.
Agents and ObjectOrientedProgramming
approach is employed when a particular situation requires that processing be decentralized and SelfOrganized?
, instead of CentrallyOrganized?
. While a CentrallyOrganized?
program could have been written to handle the bird simulation, the system would have been far too cumbersome. It would have required a single set of top-level rules telling each bird precisely what to do in every conceivable situation. Not only would such an application be TouchyAndFragile?
, it would likely end up looking jerky and unnatural?more like an animated cartoon than animated life. (See MitchellWaldrop?
's book Complexity ISBN 0671872346
Yet, most developers tend to build CentrallyOrganized?
applications. They are also biased towards ObjectOriented
notions, such as class, association, and message. While these constructs are useful for a certain category of applications, they do not directly address the RequirementsOfAgents?
. As we have seen above, agents have such characteristics as autonomy, mobility, and adaptability. Furthermore, business users like to express other concepts, such as rules, constraints, goals and objectives, as well as roles and responsibilities. In short, the AgentOriented
approach distinguishes between autonomous, interactive, mobile entities (agents) and the passive ones of conventional ObjectOrientedProgramming
(objects). This does not mean that ObjectOrientationIsDead
or pass? A well-designed AgentBased
system uses both objects and agents?just as real-life organizations employ a balance of both active and passive elements. Furthermore, ObjectTechnology?
can be used to enable, rather than drive, AgentOriented
This is all very nice, but WhatIsAnAgent
You can trivially describe an Agent as an object with its own thread of execution.
But that would be wrong, generalizing form a specific and artificial example (What's the logical error here? I forget its name): I, myself, am an "agent", yet I have no (or perhaps many) threads, none of which is clearly defined. And in
aren't necessarily SoftwareAgents. I'd say you can only define an "ArtificialAgent?" or maybe a SoftwareAgent with this trivial definition. -- BillTozier
By thread, I meant more along the lines of "thinks by itself." But "thinking" isn't sufficiently general an action. Of course, I am only giving the trivial definition I know. I'm sure others know better.
In philosophy, an agent is more or less (mostly less) a person. A being that has an individual perspective and individual behavior.
In chemistry, an agent is something that acts.
The basic idea is that an agent acts by itself and of its own accord.
It comes from the word agere
which means to act
. (Compare agir
in French.) -- SunirShah
Agent is another one of those words (like Object-based) that is being munged by marketing and programmer hype. An agent is a specific thing and there is an entire taxonomy of agents. When most people loosely refer to a SoftwareAgent
, they are normally referring to a specific type of AutonomousAgent
called a Task Specific Agent or, its child, an Information Agent. Here's a pretty good definition for the root of all agents -- the autonomous agent
. I'll follow this with a quote from Stan Franklin and the most common taxonomy of agents. -- RobertDiFalco
Here's a great quote from Stan the Man Franklin...
- autonomous agent
- An entity that, by sensing and acting upon its environment, tries to fulfill a set of goals in a complex, dynamic environment. Properties: (1) it can sense the environment through its sensors and act on the environment through its actuators; (2) it has an internal information processing and decision making capability; (3) it can anticipate future states and possibilities, based on internal models (which are often incomplete and/or incorrect); (4) this anticipatory ability often significantly alters the aggregate behavior of the system of which an agent is part. An agent's goals can take on diverse forms: (i) desired local states;(ii) desired end goals;(iii) selective rewards to be maximized; (iv) internal needs (or motivations) that need to be kept within desired bounds. Since a major component of an agent's environment consists of other agents, agents spend a great deal of their time adapting to the adaptation patterns of other agents.
And here's the usual taxonomy of agents (of which there are nodes I disagree with)...
- What constitutes an agent is a controversial topic these days. What follows describes how I intend to use the term. Put briefly, an autonomous agent senses and acts upon its environment in the service of its own agenda. Examples are to be found among humans (you and I), other animals, autonomous mobile robots, artificial life creatures, and software agents.
- Thus an autonomous agent is situated within some environment, perhaps our real world, or an artificial environment within a computing system, or within an operating system, a database, or a network. The agent actively senses its environment, and acts upon it so as to effect what it may sense next. This interactive sensing and acting aims to achieve goals that can be expected to satisfy drives. These drives may have evolved, as in us or other animals, or may have been designed and built in as in robots, artificial life agents, or software agents.
- An extensive discussion of what constitutes an autonomous agent, how software agents differ from other programs, and of how agent can be classified can be found in "Is it an Agent, or just a Program?: A Taxonomy for Autonomous Agents" by Art Graesser and myself . It's also available in postscript at ftp://ftp.msci.memphis.edu/comp/caat/agentprog.ps.z.
- Biological Agents
- Robotic Agents
- Computational Agents
- Artificial Life Agents
- Entertainment Agents
- Task-Specific Agents
- Information Agents
- Cooperative (Cobots)
Okay, now to me, it seems strange to make Adaptive
peers, maybe I'm reading in an implication of mutual-exclusion that is not really in this taxonomy. I suppose there is nothing that prevents an agent from being both mobile and adaptive.
One imagines there is a VennDiagram?
of agents, perhaps based on JamesOdell
? -- BillTozier
See also WikiMind
, how a WikiForum
forms a generalized
in the sense of MarvinMinsky
". I think any 'state of the art' Wiki is the natural homestead of WikiAgent
s, i.e. human and non-human agents (hopefully entertaining, friendly, constructive and collaborative). -- FridemarPache
I don't think so. In Minsky's view, almost all the personas were aimed towards the same goal. This Wiki is more like a "community" where diverse people are after diverse goals, but are all merely peripherally aware of protecting and advancing their common environment (i.e. the "community"). -- SunirShah
P.S. We should probably extract this to MeatballWiki
when you're ready.
Sunir, I've prepared WikiAgent
as an InterfaceWikiPage
, aimed to MeatballWiki
(or any other interested WikiForum
where this is on topic). However I think, it would be unfair to wipe out the small context that leads to the InterfaceWikiPage
. I inserted generalized
to include the WikiMind
as a special case of the generalized Minsky construct. -- FridemarPache
I have a rule of thumb that I use when reading or discussing anything to do with software agents: replace the word "agent" with the word "program" wherever it appears and see if I changed the meaning of in doing so. I have never read a single paper or listened to a single seminar where I have. -- NatPryce
Nat, you can say that for anything
. But people don't generally consider programs to be mobile, emergent, or even autonomously collaborating. I'd have to disagree with your statement. It's like saying replace the word agent
with the word object
. You could do it, but you'd miss the subtleties which make agents unique. -- RobertDiFalco
I would argue that, in the case of agents, you don't [miss the subtleties]. "Object" is a well defined term - data and behavior encapsulated behind a strict, polymorphic interface - that does introduce subtleties. Thinking in terms of objects affects the way you design and implement a system.
What subtleties are there in the word agent. If I am building a system as multiple agents, how is that different from building a system as multiple programs?
An agent is
a program. Some people talk about "mobile agents"; this case there is no additional meaning added by the word agent that is not covered by "mobile program". Some people talk about "autonomous agents"; any program that makes decisions on its input without human intervention is autonomous. Some people talk about agents as programs that act on behalf of users; programs do this already. Some people talk about agents as static programs that cooperate to achieve some task; this is no different from programs that are part of a distributed system.
IMHO, agents are a "marketechture" that is used for generating research grants.
I see this argument made every time some existing paradigm or idiom begins to gain widespread popularity. We all desire to frame unfamiliar concepts in familiar terminology - it is natural for us over generalize
until we become familiar with the distinguishing phenomena. The same thing happened with the term object
. Today, it is so easy for us to see the subtleties of an object. This is easy for you to do because you are very comfortable with the distinguishing features of an object when compared to plain old data
or function libraries. When anyone approaches something new, it is just a thingie
that is a lot like that other thingie
they are already familiar with.
As for an agent being nothing more than a program, why stop at agents? Why not call an object a program? In the strictest sense, an object can behave like a program. You can even call a C function a program? However, we don't do this because it diminishes their unique properties when work on complex systems where ambiguities needs to be diminished. Calling them all programs makes collaboration and refinement much more difficult.
In my view, an agent is much more an ActiveObject
(i.e. an object with its own thread of execution) than it is like a program. We don't normally think about programs as entities that autonomously collaborate in parallel over process boundaries much less that can move around while doing this. While the term program has been used in this way, we generally think of it as a special
kind of program. In the agent-field, this special kind of program is one of the many types of agents that an agent-based system might employ but more often than not, it is a program that is running
the instructions of the agent. I don't see any "marketechture" to correctly using the term agent and I am
glad that research into MultiAgentSystem
s and AgentCommunicationLanguages?
(like KQML and S-KQML) are finding grants
. The true marketechture
of agents is what happens when programmers and marketers (of which you are definitely not one) start calling anything
they can an agent just to exploit the happening
buzz-word of the day.
For me, this thread gives me an eerie feeling of déjà vu. I remember, as Object-Orientation gained acceptance, many of our community would go off deep end (a) and call everything
object-based while many other's of us went off deep end (b) and stated that there is nothing truly unique about O-O
or that this is how they always developed software
. Only after prolonged experience with OO did all of us realize how different OO truly was from the way we were used to working. Others who did not embrace OO may have never changed their point of view.
Consider this. When you are designing a system that makes use of the ModelViewController
pattern, do we call all the participants objects
? Do we make a distinction between the Model
or the View
? If we didn't, things would get very confusing very fast. However, because we are
familiar with this idiom, we have no problems recognizing the distinction between an object that is a Model
and an object that is a View
. In our team, we tend to use classes and
classifying terms. To enforce this, we require that each project have a Glossary to define the system metaphors, remove ambiguity, and deflect synonyms. For most of us, even though a Model object and a Controller object are both objects, there is still value to calling one a Model and the other a Controller.
Finally, let me leave you with this. In most Agent systems, the "program" is not
the agent but the agent's Execution Environment
. This is a very important distinction. The agent is an object (it may be mobile or stationary
) that is executed
within the Execution Environment provided by a program. A mobile agent is only unique in that it can move itself and its state between the execution environments of multiple programs. When you start thinking about security and other issues, the distinctions between a traditional program and an agent become even more critical. An agent has special security consideration that are different from the security consideration of the program that is executing that agent.
Can't you say that about any program other than an operating system?
- Sure, but you can also say it about objects. To me, an agent is much more like an object than a program. However, I don't use the term object instead of agent because agents don't have to be software and, when they are, they do not have to be programmed using object-oriented idioms. (Although, my guess is that OO would produce superior SoftwareAgents). While I don't like over-generalizing, I'd be less resistant to calling a SoftwareAgent an active-object than I would be to calling all SoftwareAgents programs. -- RobertDiFalco
Ok, if you say that an "agent" is an interpreted program that can choose to move between execution environments (e.g. interpreters), then I would say that the term "agent" is
a useful one, and does imply subtleties in the way that "object" does.
However, that is not the globally accepted meaning of "agent". E.g. agents in MultiAgentSystem
s are not mobile. There are a lot of different research areas that use the term "agent", and to distinguish themselves they add adjectives to the term, such as "mobile agent", "cooperative agent", etc. Thus, the meaning of the word agent degrades to nothing more than "program".
(I would also argue that allowing a running process to move itself between hosts is not particularly useful. It's a cool technology and I would love to see an application of mobile processes
that solves problems better than just
, because it looks so fun to program! Unfortunately I have not yet seen such an application.)
As for "cooperative agents" and multi-agent systems being developed by distributed AI researchers, this work has produced, and is producing, some very useful algorithms and protocols. However, just as with traditional AI, as soon as the research results in an algorithm that mimics intelligent behavior, it is no longer considered as intelligence and becomes another algorithm used by other fields of computing. E.g. The BlackboardMetaphor
resulted from distributed AI research, but is used in many applications that would not be considered as AI or agent systems.
[As for me being "so willing to now say [the term object] has subtleties", I have never not
said so. It is obvious to me that object-oriented programming is different from modular programming with ADT's, or logic programming, or functional programming. It is obvious to me that programming with mobile processes is different from object oriented programming. If I have written that the term object does not have subtleties, please remind me of when/where and I'll remove this paragraph. Otherwise, I would be grateful if you tone down what reads like an ad hominem attack.]
Anyway, we could argue round in circles till the cows came home and not get anywhere... How about we decide on what "agent" does mean, at least on the Wiki. Based on the largest intersection of all the other meanings of "agent", perhaps agent means "program that communicates over a network with programs written by other organizations".
Why not just use the existing definitions, why make up new ones?
As for attacking you, I think you may have misinterpreted my tone and I may have used the universal
you when what I really mean was one
. I'll go back and refactor that so it is less open to misinterpretation. But nothing I said was meant as an attack on you. When I spoke of how many programmers initially reacted to OO, this was in now way directed at you personally. It was only meant as an analogy to how many try to over-generalize software agents. I have no idea how you viewed OO when you first encountered it but I completely believe you when you say you immediately recognized the subtleties in objects and the object-oriented way of programming. -- RobertDiFalco
[mobile-agent]...then I would say that the term "agent"
is a useful one, and does imply subtleties in the way that "object" does. However, that is not the globally accepted meaning of "agent"...
I think this is exactly why
the term agent is useful. If you start cutting down on the types of agents the term program works for, why bother. If you are dealing with a hierarchy of things, it is often better to give them a base
label - in this case agent
or autonomous agent
. Even with
a stationary software agent
, I see these as behaving much more like a TupleSpace eval
-call or as an active-object (i.e. an object with its own thread of execution) that runs within
an execution environment than behaving like a program. Plus the term program is already so horribly overloaded and ambiguous. The JohnVonNeumann
definition of program was a single-threaded sequence of instructions executed by the computer one at a time. Now, if you ask 10 engineers what a program
is, you might get back 5 different answers that are all somewhat correct. I would agree that a SoftwareAgent
created in an object-oriented system is not that much different than an object and that a MobileAgent
not much different than a MobileObject?
. However, we need a term that will work regardless of the implementation. -- RobertDiFalco
I thought an Agent was someone who worked for the F.B.I. or was one of those bad guys in TheMatrix?
But of course that's one of the best wry InsideJokes?
. The Agents are SoftwareAgent
s. -- BillTozier
Another is that matrix
No, it doesn't. It means "female breeding stock". Womb is "uterus". (My first inclination was to think "ventris", as in, "benedictus fructus ventris tui", but that apparently means "belly".) -- JohnDouglasPorter
I've been wondering about agents myself for a couple of years, but I think I'm starting to get the hang of it. Let's all agree to ignore marketeers, except possibly as a useful source of noise for generating random numbers. We should come up with sensible, useful definitions, then use them.
I agree with much of what's been written above, especially:
- we should make a property-based taxonomy of Agents
- we should let the term Agent be as unrestrictive as possible
- the reactions to Agents are similar to reactions to previous new ways of looking at things
- while we're only going to be constructing software Agents, the term applies beyond just software systems
With regard to the "agents are just programs" debate: when discussing agents, it's helpful to distinguish between the analysis domain and the implementation domain. Reducing something to the implementation domain (projecting it into the implementation domain?) also reduces away a lot of other stuff. In other words, if you think about an agent, and then think about how you'd implement it, of course it'll look very much like everything else you've ever implemented: a program, or an object that runs inside some other program.
By analogy, a lot of OO programs don't look very OO once the compiler gets through with them; you have to look for the OO concepts at higher levels: source code, design, analysis. For Agents, look for the agent concepts in the analysis level first; maybe some of them will trickle down into the design and source code, depending how you decide to write it.
If we take "agent" in its broadest sense, as something that acts, then most of the programs I can think of count as (degenerate) agents. Even "autonomy" includes the option to autonomously sit there waiting for someone to request something from you (e.g. a human butler is autonomous, but spends a lot of time in passive mode).
What if we look at Agent
there, and giving us a direction to go in
? We're encouraged to sort things into new categories: agent, execution environment, goal, agent coordination. It should open our eyes to aspects of software that we've previously missed -- to wit:
- some programs or objects seem to have goals (e.g. the Vikings want to take over the world in Civilization II; ScanDisk? wants to put the disk in a consistent state before letting you work with it)
- some have behavior that depends a little, but not entirely, on the context (e.g. price-extracting code for site A vs. that for site B)
- some objects are really doing the same thing, only in different execution environments (e.g. email fetcher, newsgroup fetcher)
- humans have goals, operate in a different context from programs', etc. - why not treat interaction with humans the same as interaction with software agents? Now we can bring polymorphism and the rest of the OO concept toolkit to bear.
Again, it's not: "This is a radically different way of doing things, which has never been done before." It's: "Well, we have a lot of useful software. What's a good way to generalize what it does, and how we look at it?"
So some things that are too trivial to look much like goals (e.g. ScanDisk?
's behavior) can actually be viewed as goals, which encourages us to think about how to usefully extend that behavior (e.g. let the user tell ScanDisk?
to *defer* scanning until the system is idle, or until the next startup, etc.).
The new way of sorting things also lets us identify
things that we'd previously considered to be disparate, especially chunks of behavior in different execution contexts. For example, say you had Java sorting code that runs on a client, and SQL sorting code that runs on a server. The Agent way of viewing things encourages you to look at the situation this way:
- there's really only one thing doing the sorting; call it SorterAgent
- SorterAgent has to deal with Vectors of objects in the client context
- SorterAgent has to deal with SQL tables in the server context
- SorterAgent has to carry out its actions by calling Java objects in the client context
- SorterAgent has to carry out its actions by producing SQL code in the server context
- in initial implementations, maybe all that actually moves to the server is a string containing SQL code
- initially, SorterAgent needs to be told what things to sort on, in what order, and in what direction -- and also what context (client or server) to use
- later, you could add the ability for the user to choose whether to sort on the client or on the server dynamically
- even later, you could have SorterAgent make guesses about where to sort, or even start sorting on the client, give up after a while, and make another attempt at the goal by sorting on the server
Finally, even if the term "agent" seems to evaporate away into a trivial definition ("something that acts"), it still plays a useful role as a place-holder when we talk about agents coordinating with other agents (think CompositePattern
). In fact, it's this very generality that lets us plug humans
into agent systems easily (though we'll need Adaptors, such as web browsers, when we get down to implementation).
I have to wonder if part of the dispute is because the term is used in other disciplines that are seeking to model mobile entities that contain their own rules, react to their environment, change over time, yadda, yadda, yadda. You, know sociology, biology, anthropology, physics, and so on. You (no one in particular) know, anywhere that that the ideas of distributed systems and emergent behaviour might play a role. They generally don't refer to the subjects of their disciplines as objects or programs unless they are in fact those things. --AnonymousDonor