Intelligent multi-agent systems offer promising approaches for knowledge-intensive distributed applications. Now that such systems are becoming applied on a wider industrial scale, there is a practical need for structured analysis and design methods, similarly as exist for more conventional information and knowledge systems. This is still lacking for intelligent agent software. In this paper, we describe how the process of agent communication specification can be carried out through a structured analysis approach. The structured analysis approach we propose is an integrated extension of the CommonKADS methodology, a widely used standard for knowledge analysis and systems development. Our approach is based on and illustrated by a large-scale multi-agent application for distributed energy load management in industries and households, called Homebots, which is discussed as an extensive industrial case study.

The process of agent communication modeling has not yet received much attention in the knowledge systems area. Conventional knowledge systems are rather simple with respect to their communication structure: often it is a straightforward question-and-answer sequence between system and end user. However, this is different in recent intelligent multi-agent systems. Therefore, agent communication aspects are now in need of a much more advanced treatment in knowledge management, acquisition and modeling. In general, a much better integration between the respective achievements of multi-agent and knowledge-based systems modeling is an important research goal. In this paper, we describe how agent communications can be specified as an extension of well-known knowledge modeling techniques. The emphasis is on showing how a structured process of communication requirements analysis proceeds, based on existing results from agent communication languages. The guidelines proposed are illustrated by and based on a large-scale industrial multi-agent application for distributed energy load management in industries and households, called Homebots. Homebots enable cost savings in energy consumption by coordinating their actions through an auction mechanism.

The deregulation of the European energy market, combined with emerging ad-vanced capabilities of information technology, provides strategic opportunities for new knowledge-oriented services on the power grid. HOMEBOTS is the name we have coined for one of these innovative services: decentralized power load management at the customer side, automatically carried out by a ‘society’ of interactive house-hold, industrial and utility equipment. They act as independent intelligent agents that communicate and negotiate in a computational market economy. The knowl-edge and competence aspects of this application are discussed, using an improved version of task analysis according to the COMMONKADS knowledge methodology. Illustrated by simulation results, we indicate how customer knowledge can be mo-bilized to achieve joint goals of cost and energy savings. General implications for knowledge creation and its management are discussed.

General equilibrium theory has been proposed for resource allocation in computational markets. The basic procedure is that agents submit bids and that a resource (re)allocation is performed when a set of prices (one for each commodity) is found such that supply meets demand for each commodity. For successful implementation of large markets based on general equilibrium theory, efficient algorithms for finding the equilibrium are required. We discuss some drawbacks of current algorithms for large scale equilibrium markets and present a novel distributed algorithm, CoTree, which deals with the most important problems. CoTree is communication sparse, fast in adapting to preference changes of a few agents, have minimal requirements on local data, and is easy to implement.

Eight European Workshop on Modelling Autonomous Agents in a Multi-Agent World

The requirements on real-time systems are changing. Traditionally, reliability and predictability of, especially hard, real-time systems were the main requirements. This lead to systems that were stand-alone, embedded and static. Future real-time systems, but also current systems, still require reliability and predictability, but also distribution of the real-time system, integration with non real-time systems and the ability to dynamically change the components of the system at runtime. Traditional approaches to real-time system development have difficulties in addressing these additional requirements. Therefore, new ways of constructing real-time systems have to be explored. In this article, we develop a real-time object-oriented model that facilitates the requirements of flexibility without sacrificing the predictability, integration and dynamicity aspects.

Traditionally, finite state machines based approaches are used in real-time object-oriented systems development for modelling the dynamic behaviour of an object. Finite state machines based approaches, however, suffer from several problems when used for modelling large and complex objects. As an alternative, an extended object model, LayOM, and an associated modelling approach is proposed aiming to solve the aforementioned problems and other problems related to object state.

Several authors have identified that the only feasible way to increase productivity in software construction is to reuse existing software. To achieve this, component-based software development is one of the more promising approaches. However, traditional research in component-oriented programming often assumes that components are reused "as-is". Practitioners have found that "as-is" reuse seldomly occurs and that reusable components generally need to be adapted to match the system requirements. Existing component object models provide only limited sup-port for component adaptation, i.e. white-box techniques such as copy-paste and inheritance and black-box approaches such as aggregation and wrapping. These techniques suffer from problems related to reusability, effi-ciency, implementation overhead or the self problem. To address these problems, this paper proposes superimposi-tion, a novel black-box adaptation technique that allows one to impose predefined, but configurable types of functionality on a reusable component. Three categories of typical adaptation types are discussed, related to the component interface, component composition and component monitoring. Superimposition and the types of com-ponent adaptation are exemplified by several examples.

Conventional compilers often are large entities that are highly complex, difficult to maintain and hard to reuse. In this article it is argued that this is due to the inherently functional approach to compiler construction. An alternative approach to compiler construction is proposed, based on object-oriented principles, which solves (or at least lessens) the problems of compiler construction. The approach is based on delegating compiler objects (DCOs) that provide a structural decomposition of compilers in addition to the conventional functional decomposition. The DCO approach makes use of the parser delegation and lexer delegation techniques, that provide reuse and modularisation of syntactical, respectively, lexical specifications.

The application domain of compiler techniques is changing. Whereas previously compiler techniques were primarily used for the construction of compilers for general-purpose languages, now these techniques are increasingly often used for the construction of application domain languages and extensible language models. However, the traditional compiler techniques suffer from problems of complexity, maintainability, reusability and extensibility, and new approaches are needed. In this paper, we describe the notion of delegating compiler objects (DCOs), a novel approach to compiler construction that provides structural decomposition and reusability of compiler specifications. Our extensible language, the layered object model, is used to illustrate the advantages of the DCO approach for compiler construction.

Design patterns are useful for the design of object oriented systems. The power of design patterns stems from their ability to provide generic solutions to reappearing problems that can be specialized for particular situations. The implementation of design patterns however, has received little attention. We identify four problems associated with their implementation using conventional object oriented languages. First, the traceability of a design pattern in the implementation is often insufficient; the design pattern is "lost". Second, because several patterns require an object to forward messages to other objects to increase flexibility, the self problem often occurs. Third, because the pattern implementation is mixed with the domain class, the reusability of pattern implementations is often limited. Finally, implementing design patterns may present significant implementation overhead for the software engineer. Often, a potentially large number of simple methods must be implemented with trivial behavior. A solution to these problems is presented in the context of the layered object model (LayOM). LayOM provides language support for the explicit representation of design patterns in the programming language. LayOM is an extended object oriented language which contains several components that are not part of the normal object model, such as states, categories and layers. Layers are used to represent design patterns at the level of the programming language. Example layer types for eight design patterns are presented. Because LayOM is an extensible language, the software engineer may extend the language model with abstractions for other design patterns

The work done concerning object oriented frameworks is in its beginning and most of it tend to concentrate on object oriented frameworks that has been built and how these were built and documented. But there is one question that remains unsatisfactorily answered, i.e. what is a object oriented framework? This is still one of the most common questions and there still exists no answer that is generally agreed on. In this paper some important characteristics of object oriented frameworks are presented, existing definitions discussed and an improved definition is suggested.

Large object-oriented systems have at least four characteristics that complicate object communication: the system is distributed, it contains large numbers of objects, objects need to be reallocated at run-time, and objects can be replaced by other objects in order to adapt to the dynamic changes in the system. Traditional object communication is based on sending a message to a receiver object known to the sender of the message. At linking or instantiation time, an object establishes its acquaintances through name/class-based binding and uses these objects throughout its lifetime. If this is too rigid, the software engineer has to implement the binding of objects manually using pointers. We found the traditional acquaintance communication semantics to be too limited, and we identified several problems related to the reusability of objects and selection mechanisms, understandability and expressiveness. It is important to separate a class or object's requirements on its acquaintances from the way an object selects and binds its acquaintances in actual systems. We studied the necessary expressiveness for acquaintance handling and identified four relevant aspects: type and duration of binding, conditions for binding, number of selected objects, and selection region for binding. To implement these aspects, we defined acquaintance layers as part of the layered object model. Acquaintance layers uniformly extend the traditional OO acquaintance handling semantics and allow for the first-class representation of acquaintance selection and binding, thereby increasing traceability and reusability

Programming languages and software engineering methods are highly related in that both are images of an underlying paradigm. In this paper we investigate the role of the paradigm, the language model and the software development method and define requirements on each of the three concepts. Subsequently, we describe the {\em layered object model}, an extended object model which allows for first-class representation of relations between objects and constraints on the behaviour of an object, and discuss how it achieves {\em paradigm extensibility}, i.e. extensibility of the paradigm and the supporting language model.

Conventional grammar specification and parsing is generally done in a monolithic manner, i.e. the syntax and semantics of a grammar are specified in one large specification. Although this might be sufficient in static environments, a modular approach is required in situations where the syntax or semantics of a grammar specification are subject to frequent changes. The problems with monolithic grammars are related to (1) dealing with the complexity, (2) extensibility and (3) reusability. We propose the concept of {\em parser delegation} as a solution to these problems. Parser delegation allows one to modularise and reuse grammar specifications. To achieve this, the notion of a production rule is specialised into (1) overriding, (2) extending and (3) delegating production rule types. To experiment with parser delegation, we have developed D-yacc, a graphical tool for defining grammars. Parser delegation has been applied for constructing a translator for an experimental language and is currently applied in other domains.

Although object-oriented methods make extensive use of relations between objects, these relations, other than inheritance and part-of, cannot directly be represented by the conventional object-oriented model. This means that relations which are identified during analysis and design have to be implemented on top of the object model, i.e. by using method code and message passing, rather than by expressing relations directly within the model. It would be beneficial if the object oriented model would support the specification of all relevant types of relations within the model, including application-domain specific relation types. Therefore, we propose a mechanism, implemented in LAYOM-an extended object model, that supports the specification of all types of relations between objects within the model as components of the object model. In addition, an approach for identifying and specifying application-domain relation types is presented.

Although object-oriented methods make extensive use of relations between objects, these relations, other than inheritance and part-of, can not directly be represented by the conventional object-oriented model. This means that relations which are identified during analysis and design have to be implemented on top of the object model, i.e. by using method code and message passing, rather than by expressing relations directly within in the model. It would be beneficial if the object-oriented model would support the specification of all relevant types of relations within the model, including application-domain specific relation types. Therefore, we propose a mechanism, implemented in LayOM -- an extended object model, that supports the specification of all types of relations between objects within the model as components of the object model. In addition, an approach for identifying and specifying application-domain relation types is presented.

The report is the result of a course for PhD students on software architecture. An overview of the state of the art is presented. Discussed topics include describing, evaluating and designing architectures, product-line architectures, object-oriented frameworks and component-based software engineering.

During the last years, one can recognise a development towards application domain languages and extensible language models. Due to their extended expressiveness, these language models have considerable advantages over rigid general purpose languages. However, a complicating factor in the use of extensible language models are the conventional compiler construction techniques. Compilers constructed using these techniques often are large entities that are highly complex, difficult to maintain and hard to reuse. As we have experienced, these characteristics clearly complicate extending existing compilers. As a solution to this, we developed an alternative approach to compiler construction is proposed, based on object-oriented principles. The approach is based on delegating compiler objects (DCOs) that provide a structural decomposition of compilers in addition to the conventional functional decomposition. The DCO approach supports modularisation and reuse of compiler specifications, such as lexer and parser specifications. We constructed an integrated tool set, LETOS, implementing the functionality of delegating compiler objects.

Recently, one can recognize an increased awareness in the object-oriented research community with respect to the role of software architectures. Examples of this can, among others, be found in object-oriented frameworks and design patterns. In the call for papers for the workshop, the following topics were identified where software architecture, patterns and frameworks should be studied in more detail: · Building OO software architectures: How can design patterns, frameworks and components be included in the traditional object-oriented analysis and design? How are architecture constraints processed to build OO software architectures? Which techniques can help to build an OO architecture that supports reuse and is scalable? · Language role in architecture: What is the role of a particular object-oriented language when designing an architecture? · Architecture documentation: It has been suggested that design patterns can be used to document the design and rationale of an object-oriented architecture. How well does this work in practice? · OO architectural styles: What is the relation between the architectural styles of Garlan and Shaw and OO design? · Composition of architectures: Since object-oriented frameworks are an accepted technology within the software industry, the composition of two or more frameworks in an application occurs increasingly often. The composition may be far from trivial and the problems that may appear as well as solutions should be investigated. · Component technologies and architectures: Components are becoming key elements of reusable software development, and various technologies have emerged to support the specification of components and their use in unpredictable combinations (e.g. Java Beans). What are the relations between component-oriented and framework-oriented architectures? How do different component communication mechanisms affect the architecture? · Architecture evaluation: Even though object-oriented frameworks claim to promote reuse and decrease development cost, there are no techniques available to evaluate a concrete framework to determine whether it supports the functional and, especially, non-functional requirements for an application intended to be built based on the framework. 'Domain creep': Several examples of frameworks exist that, over time, are applied in domains differing from the originally intended domain. The framework then needs to be adapted to include the new domain as well, either as an integrated framework or as two versions. The problems associated with domain creep need to be identified and solution strategies identified. · Experiences: Object-oriented software architectures are used out in industry and academia. However, often no explicit evaluation is performed and experiences are not captured and described objectively. The experiences, case studies and concrete systems and identify problems and weaknesses, but also successful structures and approaches need to be described. · Tool support: A considerable need for architecture tool support exists. Examples are visualization, editing, design, and documentation of architectures. The goal of the OOSA'98 workshop was to study the aforementioned topics, define the research area and state-of-the-art in more detail and to identify open problems. The call resulted in 15 papers accepted for the workshop. These papers were divided over 5 sessions. Each session was divided in a presentation part, in which the authors briefly presented their work, and a discussion part where the audience was able to discuss the presented and related ideas with the authors and each other. In the remainder of this workshop summary, the results from each session are presented.

Software architecture research is receiving increased amounts of attention in academia as well as in industry. Therefore, in 1997 the initiative was taken by the University of Karlskrona/Ronneby to start a network of academic and industrial partners, SARIS, interested in various aspects of software architecture. The intention of the SARIS (Software Architecture Research in Sweden) network is to bring together partners with common interests, exchange experiences through the mailing list and regular meetings and to develop cooperation wherever possible. The term software architecture is somewhat overloaded, but most experts agree that it primarily refers to the top-level decomposition of a system into its main components and the interaction between these components. A second aspect is that software architecture design is primarily concerned with the non-functional requirements (also properties or quality attributes) of software systems, rather than their functionality. Attributes can be categorized into operational attributes, such as efficiency, reliability, robustness and cor-rectness, and development attributes, such as maintainability, flexibility and reusability. The architecture structures the functionality required from a system such that the non-functional requirements are fulfilled.

When modelling complex computer systems, four primary modelling techniques are available to the software engineer, i.e. abstraction, composition, functional decomposition and multiple client interfaces (views). Abstraction and composition can directly be expressed in traditional object-oriented models and functional decomposition can often be expressed using subsystems. However, traditional object models provide no expressiveness for multiple client interfaces. This forces designers to either model all different views on a conceptual object as a large, complex implementation object or to model each view as an object and relate the different view objects. Both approaches suffer from problems of complexity, maintainability and reusability. As a solution, we propose the layered object model that allows for the expressive, flexible and extensible definition of multiple client interfaces. To illustrate the problems associated with views and our proposed solution, the domain of industrial control systems is used.

The requirements on real-time systems are changing. Traditionally, reliability and predictability of hard, real-time systems in particular were the main requirements. This lead to systems that were stand-alone, embedded and static. Future real-time systems, but even current systems, still require reliability and predictability, but also distribution of the real-time system, integration with non real-time systems and the ability to change dynamically the components of the system at run-time. Traditional approaches to real-time system development have difficulty in addressing these additional requirements. New ways of constructing real-time systems must therefore be explored. In this article, we develop a real-time object-oriented model that facilitates the requirements of flexibility without sacrificing the predictability, integration and dynamicity aspects.

Since the architecture of a software system constrains the non-functional requirements, the decisions taken during architectural design have a large impact in the resulting system. An architectural design method is presented that employs iterative evaluation and transformation of the software architecture in order to satisfy the non-functional requirements (NFRs). Architecture evaluation is performed by using scenarios, simulation, mathematical modelling and reasoning. The architecture can be transformed by imposing an architectural style, imposing an architectural pattern, using a design pattern, converting an NFR to functionality and by distributing NFRs. The method has, in various forms, been applied in several industrial projects.

Due to changing circumstances, organisations start to co-operate with their competitors or with firms form other industries that can complement their range of products. This development of independent partners sharing, their resources and equipment with each other, can also be seen in the Swedish utility industry and will soon happen to other utility businesses after the deregulation of the European utility industry has become a fact. The co-operation can be seen as a virtual organisation and this research project investigates how virtual organisations operate and how partners establish and maintain such an organisation. For this reason the R&D virtual organisation ISES, formed by the utility related joint venture EnerSearch AB, is taken as a case study. When comparing a virtual organisation with traditional organistions, five boundaries are presented that can both create and inhibit learning and communication. Since learning can be viewed as a major objective of a virtual organisation, the five boundaries ar e discussed in more detail and are related to empirical results in the project ISES. These boundaries in time, space, diversity, structure, and distribution are characteristics of a virtual organistion. By observing this organisation, opportunities and obstacles of a virtual organisation are found that could help organisations who would like to establish a virtual organsition. One example is the difference in decision styles or personality of the members of a virtual organistion, which influences information distribution, communication and co-operation.

The purpose of this thesis is two-fold. First the researcher wants to investigate the gradation of information needs, in order to made a classification of important information and communication aspects of the focal organisation EnerSearch. Secondly, in order to state a classification of information, a vocabulary is developed that could help actors to understand the situation under investigation. Method The methodology used is partly an action research methodology, where the researcher plays an active role in interpreting and understanding the situation together with the actors of the focal organisation. The research exerts from a hermeneutic perspective, where activities in the focal organisation are interpreted and concepts are developed that can help actors of the investigation, to understand their situation. For the investigation a case study is taken and the researcher has an active role in the case study. Conclusion The found data is summarised by using ideal types that characterise persons in the focal organisation. The ideal types used are: clients (members of the management and financiers), involved and individualists (both operating core). These three groups have different needs of information, communication and objectives. With help of these groups a classification of information distributed in the organisation is made, based on a division between: information based on destination (to whom the message is sent) and content (what is the content of the information sent). This division is used in order to find the most suitable media that could be used for transmitting this information and this is done with help of the information richness theory of Daft & Lengel (1990). By distributing information and by communicating with each other, one could also state that co-ordination is party stimulated with these results. Furthermore, the results found can be implemented in an information system that is adjusted to the requirem ents of the participants of the focal organisation. For this reason a primitive design of an information system is proposed that could support the aforementioned classification and that could support communication and information distribution in the focal organisation.

Due to changing circumstances, organisations start to co-operate with their competitors or with firms from other industries that can complement their range of products. This development of independent partners sharing their resources and equipment with each other can also be seen in the Swedish utility industry and will soon happen to other utility businesses after the European utility deregulation has become a fact. This co-operation can be seen as a virtual organisation and research is performed on how virtual organisations operate and how partners establish and maintain such an organisation. For this reason the R&D virtual organisation called ISES formed around the utility related joint venture EnerSearch AB. When comparing a virtual organisation with traditional organisations, five boundaries are presented that can both create and inhibit learning and communication. Since learning can be viewed as a major objective of a virtual organisation, the five boundaries are discussed in more detail and are related to empirical results in the project ISES. These boundaries are time, space, diversity, structure and distribution and are characteristics of a virtual organisation. By observing this organisation, opportunities and obstacles of a virtual organisation are presented that could help organisations who initiate to establish a virtual organisation. One example is the difference in decision styles or personality of the members of a virtual organisation, which influences information distribution, communication and co-operation.

In organisational science, new organisational concepts such as business process re-engineering and virtual organisations are developed. These new types of organisation have more advanced and different requirements on their information technology (IT) support, since the relation between the organisation and its IT system is much tighter for these organisation types. We disucss potential problems of traditional IT approaches in these organisations. As an alternative, we propose a different perspective on the role of IT, i.e., we view the organisation as consisting of a physical and a virtual layer that both are active, equally important and contain models of each other.

Efficient performance tuning of parallel programs is often hard. In this paper we describe an approach that uses a uni-processor execution of a multithreaded program as reference to simulate a multiprocessor execution. The speed-up is predicted, and the program behaviour is visualized as a graph, which can be used in the performance tuning process. The simulator considers scheduling as well as hardware parameters, e.g., the thread priority, no. of LWPs, and no. of CPUs. The visualization part shows the simulated execution in two graphs: one showing the threads’ behaviour over time and the other the amount of parallel-ism over time. In the first graph is it possible to relate an event in the graph to the code line causing the event. Validation using a Sun multiprocessor with eight processors and five scientific parallel applications shows that the speed-up predictions are within +/-6% of a real execution.

Rapporten omfattar en samhällsekonomisk bedömning av Karlskrona kommuns investering i en ny färjeterminal på Verkö. Bedömningen har gjorts med hjälp av en av författarna konstruerad modell för att beräkna konsumenternas betalningsvilja för en färjeförbindelse mellan Karlskrona och Gdynia. Rapporten inbegriper en samhällsekonomisk, företagsekonomisk och kommunalekonomisk kalkyl över färjeförbindelsen och investeringen, samt de fördelningseffekter som detta medför.

This report presents some initial results from simulations of a linear quasi-anticipatory autonomous agent architecture (ALQAAA), which correspond to a special case of a previously suggested general architecture of anticipatory agents. It integrates low-level reaction with high-level deliberation by embedding an ordinary reactive system based on situation-action rules, called the Reactor, in an anticipatory agent forming a layered hybrid architecture. By treating all agents in the domain (itself included) as reactive agents, this approach drastically reduces the amount of search needed while at the same time requiring only a small amount of heuristic domain knowledge. Instead it relies on a linear anticipation mechanism, carried out by the Anticipator, to achieve complex behaviours. The Anticipator uses a world model (in which the agent is represented only by the Reactor) to make a sequence of one-step predictions. After each step it checks whether the simulated Reactor has reached an undesired state. If this is the case it will modify the actual Reactor in order to avoid this state in the future. Results from both single- and multi-agent simulations indicate that the behaviour of ALQAAA agents is superior to that of the corresponding reactive agents. Some promising results on cooperation and coordination of teams of agents are also presented. In particular, the linear anticipation mechanism is successfully used for conflict detection.

A novel method for learning characteristic decision trees is applied to the problem of learning the decision mechanism of coin-sorting machines. Decision trees constructed by ID3-like algorithms are unable to detect instances of categories not present in the set of training examples. Instead of being rejected, such instances are assigned to one of the classes actually present in the training set. To solve this problem the algorithm must learn characteristic, rather than discriminative, category descriptions. In addition, the ability to control the degree of generalization is identified as an essential property of such algorithms. A novel method using the information about the statistical distribution of the feature values that can be extracted from the training examples is developed to meet these requirements. The central idea is to augment each leaf of the decision tree with a subtree that imposes further restrictions on the values of each feature in that leaf.

It is argued that in applications of concept learning from examples where not every possible category of the domain is present in the training set (i.e., most real world applications), classification performance can be improved by integrating suitable discriminative and characteristic classification schemes. The suggested approach is to first discriminate between the categories present in the training set and then characterize each of these categories against all possible categories. To show the viability of this approach, a number of different discriminators and characterizers are integrated and tested. In particular, a novel characterization method that makes use of the information about the statistical distribution of feature values that can be extracted from the training examples is used. The experimental results strongly supports the thesis of the paper.

A linearly anticipatory agent architecture for learning in multi agent systems is presented. It integrates low level reaction with high level deliberation by embedding an ordinary reactive system based on situation action rules, called the Reactor, in an anticipatory agent forming a layered hybrid architecture. By treating all agents in the domain (itself included) as being reactive, this approach reduces the amount of search needed while at the same time requiring only a small amount of heuristic domain knowledge. Instead it relies on a linear anticipation mechanism, carried out by the Anticipator, to learn new reactive behaviors. The Anticipator uses a world model (in which all agents are represented only by their Reactor) to make a sequence of one step predictions. After each step it checks whether an undesired state has been reached. If this is the case it will adapt the actual Reactor in order to avoid this state in the future. Results from simulations on learning reactive rules for cooperation and coordination of teams of agents indicate that the behavior of this type of agent is superior to that of the corresponding reactive agents. Also some promising results from simulations of competing self interested agents are presented.

A novel architecture for and some simulations of linear anticipatory behavior is presented. Compared to traditional planning, anticipation is a more passive way of reasoning. A linearly quasi-anticipatory agent architecture (ALQAAA) agent tries to predict what will happen if nothing unexpected occurs, whereas a planning agent actively evaluates what will happen when a number of different actions are performed. The main reason for this is that all agents in the environment are treated as being reactive. In addition, it is interesting to note the small amount of heuristic domain knowledge necessary to produce adaptive behavior.

The paper presents a new framework for autonomous agents that is based on the concept of anticipatory systems. It is a hybrid approach that synthesizes low level reactive behavior and high level symbolic reasoning. According to this framework, an agent, i.e. an anticipatory agent, consists of three main entities: a reactive system, a world model, and a meta level component. The world model should, in addition to the description of the agent's environment, also include a description of the reactive part of the agent. The basic idea is that the meta level component makes use of the world model to make predictions of future states. These predictions are then used by the meta level to guide the agent's behavior on a high level, whereas the low level behavior is controlled by the reactive component.