LiveWorld has had only casual testing with novice programmers. Several students succeeded in building video-game worlds using simple agents and other objects drawn from a library of video-game components (see sections 4.2.10 and 5.4.1). Obviously, more evaluation with users is needed: of LiveWorld, its implementations of agents, and the basic ideas of agent-based programming.
Dynamic Agents, at least in its present form, is probably too complex for novices. While the basic concepts of the language are not that much more complicated than those found in a procedural language, and it should not be beyond the ability of a novice to create tasks and templates, it can be very difficult to understand the resultant complex concurrent activity of the agent system. A scaled-back version of DA that eliminated concurrency and conflict detection, but retained the goal-directed control structure, might be more tractable although less powerful. There are many possible languages that lie on the continuum between a basic procedural language and DA, allowing for a tradeoff between power and comprehensibility. At the low-powered end of the spectrum, there are concepts from agent-based programming that could be usefully transferred to purely procedural languages, such as turning invocations into graphic objects and displaying them anthropomorphically.
The simpler agent systems might be more promising places to start evaluating the utility of agent-based programming for novices. The ideas behind these systems are sufficiently simple and intuitive (at least to recent generations that have grown up with video games) that they should be usable by young children. Work with children on programming environments with similar capabilities is encouraging: (Marion 1992) describes elementary-school students building animal behavior simulations in PlayGround; (Burgoin 1990) describes a group of somewhat older children building robots that are controlled by a rule-like language; and the systems described in section 6.2 also have shown that children can create behavioral simulations using agent-like constructs. None of these systems use explicit goals or anthropomorphize their agents, so it remains to be seen whether these features make agents easier to understand or not. It would also be interesting to study the nature of children's anthropomorphization of computers and program parts, and whether these tendencies are different in agent-based systems.
The understandability of any programming system will be based both on the underlying concepts and on how well those concepts are presented to the user through the interface. Thus, the answers to this question and the next will be linked together.
Like any complex system, agent systems can be hard to understand. However, agent systems also suggest new techniques for presenting program activity. The use of narrative techniques to explain (and eventually to produce) agent activity is one of the more interesting areas opened up by agent-based programming. The storyboards that DA can generate only begin to explore this area. Presenting the activity of complex collections of hundreds of agents will require more knowledge about characters and narrative.
The representation of agents in anthropomorphic terms can be extended. There are additional emotional states that can be used to reflect computational states (such as surprise to indicate an expectation violation (Kozierok 1993)). The magnitude of emotions such as happiness or anger can be conveyed by parameterizing facial displays (see section 5.5.4.4). Perhaps more importantly, there is a need to individualize agents so that they can be thought of as characters. Libraries of animated characters could be selected as representations that match the characteristics of the underlying agents. This idea was explored in (Travers and Davis 1993), but only for a two-agent system. Extending this idea to more complex systems of agents is an interesting challenge.
The mappings from agent activity to narrative forms can also be extended. The stories told now are all of a fairly simple type, and the technique used to tell them is simplistic. We can imagine other kinds of stories when agent systems become more sophisticated, for instance, stories about conflict being resolved into cooperation, or developmental stories in which a character learns from experience. As for the presentational forms, the medium of the storyboard has many rich possibilities, such as parallel time tracks and highlighting details, that have yet to be explored.
The Dynamic Agents system is somewhat limited in terms of the intelligence it can apply to performing its tasks. While it has some support for exploring multiple methods of achieving a goal, it cannot perform searches for solutions as do planners. Since an agent may perform arbitrary actions, it is difficult to represent the projected results of a potential action, which is planning requires. More fundamentally, putting actions under the control of a centralized planner violates the agent metaphor. Decentralized methods that simulate some of the effects of planning (such as Maes' action selection algorithm; see section 5.5.2) might be an acceptable substitute.
Other methods for improving DA performance that are more consonant with the agent metaphor are also possible. For instance, there could be agents that are outside of the standard agent hierarchy and act to improve its performance (see section 5.5.3). Manager agents like this could also be used for more sophisticated forms of conflict resolution than the contest-of-strength technique currently employed by LiveWorld. Rather than have two conflicting agents fight it out, they could refer their conflict to an outside mediator who could implement negotiation of compromises or make use of non-local information to help resolve the dispute.
Agents currently do not learn from experience, and thus have to solve each constraint problem all over again each time any element of the system changes. Smarter agents could remember which methods worked and under which circumstances, and make the correct choices without having to search through failures. Mediator agents too could have memories. Some of these techniques were explored, for extremely simple cases, in (Travers and Davis 1993). Case-based techniques were used for learning, so that situations and solutions would be remembered in a case library and matched with new situations as they arose. However, the challenge is to implement such facilities in a way that fits into the overall metaphor and makes the behavior of the system more understandable rather than more opaque. There is a tension between making the system smarter and making it more comprehensible.
The Dynamic Agents system is based on a hierarchical model of agent organization, and employs metaphors based on human managerial hierarchies. This form of organization is common in computational systems, but is problematic to some because of its metaphorical implications. Bureaucratic hierarchies can be unpleasant and inefficient in real life, so why duplicate them in the computer?
Hierarchy arises in computational systems for the same reason it does in society: to allow a measure of centralized control to be exerted over a domain that is too big or complex to be controlled by a single individual or agent. Hierarchy allows parts of the domain to be controlled by subordinate agents while keeping ultimate control centralized. This control is not obtained without a cost, however. In social systems, the costs include the ethical and political consequences that attend the subordination of individuals to the power of others. This sort of cost is presumably not a direct issue when designing a software system around social and anthropomorphic metaphors, except insofar as it might promote the idea of hierarchical subordination in general.
But there are other problems with hierarchical organization that can affect both human and artificial societies. These stem from the fact that such systems lead to long and sometimes unreliable paths of communication between the worlds they manipulate and the agents that make decisions. Information about the world must percolate upwards through a chain of command while decisions filter downwards. This process can be slow and error-prone. Hierarchical organization disempowers agents who are most in touch with the world and isolates the agents with power from the world they seek to control. Allowing subordinates a greater degree of independence can alleviate some of these problems, but at the risk (from the manager's perspective) of losing control and causing incoherent system behavior. As a result, hierarchical organizations are constantly seeking a balance between top-down control and autonomy.
The DA system was also designed to seek a balance between control and autonomy. In contrast to procedural languages, which use a strict top-down command regime, DA employs a more flexible style of control. While they are subject to hierarchical management structure, dynamic agents execute autonomously and concurrently, in the manner similar to that employed in hierarchical behavioral control systems (see 5.2). Managers actually manage, rather than command: their role is to activate and coordinate the activities of their subordinates, rather than to directly control them. The control path between perception, decision-making and action is shortened, and most commonly only involves a single level of agent.
Certainly there are other ways to organize systems of agents that avoid hierarchical models and metaphors. Perhaps an agent system could be organized around the idea of group negotiation towards a consensus, after the model of Quaker meetings. Such systems suffer from scaling problems, however, and presuppose a more sophisticated agent that is capable of representing and negotiating among alternative courses of action. Another mode of organization which avoids hierarchy is a market-based (or "agoric") system in which agents hired others to perform tasks for them (Miller and Drexler 1988). However, in such systems the relationship between agents is looser, and it is correspondingly harder for a manger to manage the activity of a "hired" agent when (for example) the subtask no longer needs to be accomplished because circumstances have changed (this sort of constraint is presumably the reason real-world economic activity makes use of both hierarchixal firms and non-hierarchical markets).
All non-hierarchical schemes have serious problems with comprehensibility. A large system of agents is a formidable thing to understand, and organizing agents along hierarchical lines is the most powerful way to make such a collection into something that can be understood. The true advantage of hierarchy, from the standpoint of comprehensibility, is that it is the scheme that allows the details of agent activity to be abstracted away. This is one reason why hierarchical organization is so highly valued in the design of engineered systems.
The question of control in agent-based systems is fraught with political overtones, and forces designers and users to think about issues of control, autonomy, power, and organization in the human world as well as the computational. There are many possible ways to organize the activity of agents. From the standpoint of constructivist education, what would be most desirable is a system that allowed users to create and explore a variety of organizational forms.
One legitimate criticism of the system as a whole is that it has a split personality: the basic LiveWorld level and the agent languages are to some extent separate, and organized around different metaphors. LiveWorld uses an unusual form of the OOP paradigm, highlighted by an interface which emphasizes the tangibility of objects. The DA system uses the agent metaphor which emphasizes action, goal-seeking, and autonomous behavior. This is partially an artifact of the system's developmental history--the object system had to be in place before the research into agents could take place. But in the future, wouldn't it be better to use a single paradigm for the system? Can an environment be made that is "agents all the way down"?
There are several answers to this question. For one thing, it is not clear that a single metaphor can really work at all levels. Agents need to take their action in a world of objects, so in some sense the operation of the agent-based level depends upon an object level already being in place. Making everything an agent, the way some OOP systems make everything an object, might require diluting the concept of agent to the point where it is no longer useful.
Still, there could be more integration between the levels. One interesting prospect is to base the agent system on a more suitable low-level general computational mechanism than Lisp and the LiveWorld object system. One candidate is the Actors programming formalism (Hewitt 1976), which already supports object-orientation, concurrency, and message-passing. Actor languages in theory could replace Lisp as the base language in which agents are programmed. Actors are already quite similar to dynamic agents in some ways. An actor is like a procedure invocation, but can also persist over time and have state. Unlike procedures, but like dynamic agents, actors do not implicitly return values. If an invoker of an actor wants a response, it must create another actor as a continuation to handle the value, and pass the continuation along as an argument.
But actors are still essentially driven from external messages rather than running as autonomously independent processes (Agha, Mason et al. 1993). They are not goal-oriented and have no built-in models for conflict resolution. Thus if Actors is to serve as a basis for an agent system like DA, it will be necessary to build a layer of agent-based protocols on top of the basic Actor model. Another problem is that the actor model has not, as yet, resulted in many practical programming tools. Actor programming can be difficult, unnatural, and verbose, and actor languages do not have the sophisticated inheritance mechanisms found in other object-oriented systems. Nonetheless the Actor model looks like a promising way to put agent-based programming on a more elegant and rigorous footing.
Animate systems naturally lend themselves to implementation in distributed and multi-user environments. In such environments, users at various locations would construct active objects that would be loosed into common areas to interact with one another. Text-based systems of this kind (called MUDs or Multi-User Dungeons) have become widespread in recent years, and show promise as environments for learning to program. The social nature of such artificial worlds provides an audience, context, and motivation for constructionist learning (Bruckman 1993).
However, the text-based nature of MUDs limits the kinds of interactions that can take place, and the programming languages that are available are often limited in what they can express. Some MUDs are inhabited by sophisticated artificial personalities (Foner 1993), but these generally are developed outside of the MUD itself, and simulate a user connected to it from the outside. Users cannot generally construct such complex autonomous actors from within the environment. The ideas of agent-based programming and the LiveWorld environment should fit naturally into shared worlds and might improve their utility. Programs in shared environments have to respond to a variety of events and changing circumstances, a task well-suited to the agent-based paradigm. LiveWorld's design encourages thinking of programs and behaviors as objects that can be manipulated inside of a graphic environment. This objectification of program components should be particularly useful in a shared social environment, allowing programs to become social objects that can be readily discussed and shared.