A diagram of this architecture
The philosophy behind MAX is that meta-reasoning and learning are best facilitated when all knowledge is uniform and declarative. MAX makes no commitment about how learning and reasoning are to be done. In fact, the architecture only supplies the programmer with a means-ends-analysis (MEA) planner. The programmer must explicitly specify how learning and advanced reasoning is done. But because the representation is declarative, the architecture "knows what it does not know."
Many ideas in MAX may be traced to Prodigy because Daniel Kuokka worked under Carbonell.
In MAX all knowledge is declaratively stored in logic frames (or lframes). Each lframe denotes a possible "state" by representing the conjunction of a set of predicate logic literals. Lframes may be composed of other lframes, and may have local variables. Associated with lframes are rules that tell when an MEA planner should utilize it. Rules match against conditions in working memory. On a large scale, knowledge is organized according to what it specifies, or what it's for. There are Behavior, Base-Domain, and Monitor specifications, as well as CurrentBehavior (i.e. state) and Other (e.g. perception and action) knowledge databases.
The MAX architecture is driven by an interpreter, or kernel, that is essentially a rule-based forward-chaining engine that operates on productions. It chooses one behavior to activate.
Although the basic architecture is rather bare, MAX is designed to support modular agents. All capabilities are elemented by specific behaviors, or modules. At any one time only one behavior is active. Behaviors may invoke each other recursively because a stack of active behaviors is kept. Monitors are like behaviors but they are automatically invoked when some pre-defined environmental condition is met. They are used to respond to a dynamic environment in a timely manner, and they may be declared at runtime.
The architecture has no built-in learning or reasoning modules -- these must be given by the programmer. Kuokka claims to have made modules (i.e. behaviors and monitors) that do:
MAX may be considered a "de-evolution" of Prodigy. The underlying logical support for modules is present in both, but MAX scales the rest of Prodigy's architecture down considerably.
MAX was purposefully designed with uniform, global, symbolic knowledge. This gives it glass-box control knowledge, which is another attribute Kuokka wanted. Though all knowledge globally accessible, it is not stored in one monolithic knowledge base. This means it need not necessarily be consistent, allowing non-monotonic learning.
Because the architecture is open-ended, learning may be deliberative or reflexive, if learning is implemented at all. Also, the modularity of an agent depends on the specific behaviors and monitors that it has.
Monitors give MAX agents an ability to react in realtime, and, a limited ability to reason in realtime. The architecture assumes it is constantly being updated with valid sensor data, thus sensing is eager (and cheap).
A MAX agent has no architecturally-defined learning or even reasoning mechanisms. But any reasoning or learning mechanism that the programmer defines may use the whole of the knowledge base and any other behavior or monitor. A simple MEA planner comes with the system, but it does not preclude other planners from being added. Basically, any desired component must be implemented by the programmer in terms of behaviors and monitors.
MAX was designed to work in robotic environments. Monitors allow it to work in dynamic environments. They allow timely attention to important aspects of the environment over ones of lesser importance.
MAX was demonstrated in a simulated robotic environment, but events could happen that were outside of its control.
With different monitors and behaviors vying for processor time MAX may handle conflicting goals. Monitors get assigned to those that must be attended to in a timely fashion. Behaviors maybe assigned to handle possibly conflicting goals, where the planner chooses which behavior to invoke based on its rule.
Because MAX's architecture is so low-level it is difficult to say anything conclusive about its rationality, taskability, scalability or efficiency.
One limitation of MAX is that, because only one behavior or module is active at one time, it does not utilize all of its knowledge to make a decision. This may manifest itself as inefficient behavior. For example, if behavior A calls behavior B, and B then calls C, and C solves A or A becomes irrelevant there is no way to jump back directly to A.
There are some limits to its reactivity to dynamicism. One is that because all data is stored declaratively, so using it takes more time. Secondly, monitors only check for specific conditions: if two or more monitors are needed then either there might be a conflict for resources, or some environmental condition might be left unattended. A third limitation might be that the burden of writing interruptable modules lies principly with the programmer. Specifically, if asynchronous-firing monitors are used, the programmer must design all monitors or behaviors that may be active to be interruptible (and resumable) at any time. Having the activation stack helps, but the limitation that monitors leave everything exactly as they found it may not lead to globally optimal behavior. Another aspect of programmer responsibility is that if the kernel does not have the ability to pre-empt long-running behaviors then environmental conditions might come and go without having their monitors invoked.
Other Architectures
Back to the Title Page