Research on software agents that have a formal description of their internal structure and functioning has been presented. This makes it possible that (1) other agents can find out what they are capable of doing, and (2) they can reconfigure themselves when needed to cope with changed environments or changes in tasks [Steels 94]. The formal description is inspired by the notion of the Knowledge Level [Newell 82] and called formal Knowledge Level model. It describes the components, internal structure and functioning of an agent from a knowledge content perspective [Clancey 83] [Chandrasekaran 86] [Steels and Mc Dermott 92] [Cuena 93] [van de Velde 93], using mathematical constructs. Formal KL-models have both a sufficient level of preciseness to be formally analyzed and manipulated by software agents, and an appropriate level of abstraction to allow other software agents to understand what an agent can do and how it does it, in an abstract and implementation-independent way [Sierra 96].
A formal KL-framework which allows the construction of modular and structured formal KL-models describing the components, internal structure and functioning of software agents has been defined. Software agents based on formal KL-models have three major components: (1) a conceptual description of their capabilities and behavior, which allows them to interact with humans; (2) a formal description of their components and internal structure, which allows them to interact with other software agents; and (3) code/execution fragments implementing their capabilities. An Application Kit exploits the componential structure of our formal KL-framework to automatically generate the conceptual and operational components of an agent from its formal description.
Our scenarios have shown that formal KL-models can be formally analyzed by software agents in order to derive properties of other agents behaviors (efficiency and accuracy, in our second scenario), and most importantly, that software agents can manipulate them by mathematical operations in order to adapt and increase the complexity of their behaviors (to build up behavior complexity, in our first scenario). In particular, they describe how formal KL-models can be used by software agents to reconfigure themselves, and to communicate about their capabilities and behaviors.
Formalization of KL-models has been extensively studied in the context
of KADS models of expertise [Wielinga, Schreiber, and Breuker 92]. The logical language we use
to describe our formal KL-framework, 
[van Harmelen and Balder 92], is a
rigorous approach to formalize complex reasoning systems [Treur and Wetter 93]
[Fensel and van Harmelen 94]. Important differences exist, however, between both
formalisms, the most relevant of which have to do with the modularity
and configurability aspects of our conceptualization of KL-models.
Instead of defining a formal specification language, we provide
reusable formal descriptions of KL-components, which can be used to
construct KL-structures. lack of abstraction mechanisms is
compensated in our formal KL-framework with the definition of formal
constructions of new types of KL-components, such as ontologies,
resolution and task decomposition methods. Ontologies not only define
an order-sorted language, as languages do, but they also
contain axiomatic definitions which define and constrain the
interpretation and well formed use of their vocabularies. Our
resolution methods differ from primitive inference actions in
that we also include information about state of execution and control.
The concept of task decomposition method does not exist in .
Our model and lift definitions add to the concepts of
formula-schemas and term-schemas, which describe the
knowledge representation formalisms used by models and resolution
method arguments. Ontologies and lift definitions play an important
role in inter-agent communication, since they allow translating
between the vocabularies and representation formalisms used by
different agents. These new types of KL-components permit us to define
composition and abstraction mechanisms, such as composition rules and
KL-structures, which are also new with respect to . The
introduction of modular formal descriptions for KL-structures
simplifies the analysis of our formal KL-models, with respect to
specifications, because they provide views of a formal
KL-model at different levels of abstraction.
[Brazier, Keplicz, Jennings and Treur 95] study the formal specification of compositional architectures for multi-agent systems. Their formal specification framework also decomposes an agent into a number of interacting components. The main difference between this work and ours is that we focus on the formal description of a single agent, while they extend their specification to task-agent allocation and inter-agent communication, as well. As a consequence, we provide a richer group of both, primitive and composite, agent modeling components. On the other hand, they describe the allocation of tasks to agents, and the activation of these tasks either sequentially or in parallel. Finally, we make explicit the declarative relationship between the input and output contents of our resolution methods, while they leave it unspecified for their primitive components.
Composition rules and their application to the configuration and reconfiguration of formal KL-models from reusable formal descriptions of KL-components and KL-structures, although restricted to a partial aspect of our formal KL-models (the KADS inference layer), are also studied in [Aben 95]. This work formalizes KADS inferences as predicates over abstract data-types, defined by precondition, body and postcondition. The inclusion of preconditions and postconditions (as those proposed by [Aben 95]) within our formal descriptions of resolution and task decomposition methods is straightforward, because of the similarity of both formalizations, and would allow us to extend the compatibility conditions of our composition rules with consistency requirements.
Contracts [Helm, Holland and Gangopadhyay 90] address the issue of abstractly specifying behavioral compositions in the context of object-oriented systems. Our formal KL-framework is also concerned with the issue of constructing complex agent behaviors from compositions of reusable KL-components and KL-structures. However, both formalisms address rather different problems, we study the abstract and formal description of agent behaviors, independently of how they are implemented, while they focus on the behavioral specification of object-oriented architectures. This fact determines, for example, the different nature of our basic components. KL-components, independently of whether they are implemented by objects or any other programming construct, describe different pieces of an agent's knowledge: what it is able to do (resolution and decomposition methods), and what information it has about the world (models, ontologies). Contracts could be extremely useful in implementing object-oriented versions of the ``operational components'' of our decomposition methods, or of uninstantiated KL-structures built up from decomposition methods. In particular, some of the concepts included in the specification of contracts, such as causal obligations and preconditions on participants (subtasks in our formalism) could be successfully applied to extend the expressive power of our formal description of decomposition methods. The idea of using special purpose methods to instantiate a particular contract on participants differs from our configuration scheme, based on composition rules. Finally, the support for standard operations on contracts such as refinement and inclusion, which resemble our specialization and import operations on the formal descriptions of KL-components and KL-structures, could be usefully exploited in order to construct contract-based Appkits able to automatically operationalize our formal KL-models.
Interesting research is also being conducted on the construction of a highly expressive Agent Communication Language (ACL), within the context of the Knowledge Sharing approach to software interoperation [Genesereth and Ketchpel 94]. ACL is intended to allow programs to exchange semantic definitions of their vocabularies, machine-processable specifications of their capabilities and needs, as well as attitudes about information, such as querying, stating, requesting and offering. Our work extends the expressive power of ACL capability specifications by not only providing formal specifications of what an agent can do, but also reporting on the exact ways in which it does it. Our formal KL-models describe, in formally analyzable/manipulable and operationalizable ways, the tasks an agent can perform, the decomposition of tasks into subtasks, resources and methods it uses to carry out each task or subtask, and its current state of execution. With respect to other aspects of ACL (semantic definitions, or attitudes about information), our approach is complementary to the efforts of the Knowledge Sharing approach to software interoperation, in that our agents can use ACL to communicate about their formal KL-models.
More experiments need to be done in order to evaluate the applicability of our proposals to the construction of different types of intelligent agents.