In a blog post about CEP being considered a supporting act for BPM and other technologies, Raimer von Ammon of CITT (University of Regensburg, Germany) commented about the EU proposal for a “U-CEP” (Ubiquitous CEP) research programme. In that comment Rainer mentioned the connection between CEP (an IT paradigm around events) and Biology (covering event-driven neural and evolutionary systems - Epigenetics and Brain Research) which form part of the U-CEP EU research programme proposal. Rainer has kindly elaborated some more on this topic, which IMHO is worthy of a separate post on this blog … and I note has parallels to one of James Odell’s posts on the “inside of an agent”…

Two or three recently emerging disciplines yield to a similar paradigm in order to explain how the environment (actually the universe of global event clouds) and their processing by sensors (respectively receptors and the activation of effectors) drive our daily life, but also the whole evolutionary process of life on our earth since the Big Bang.

The discipline of the New Biology or Epigentics has detected - on the basis of the nanotechnology, microbiology and cell biology – within the last years that the life of cells is determined by its physical and energetic environment and not by their genes. Genes are only the molecular “blue print”, the design pattern, on which the structure or architecture of cells, tissue and organs is based. But the environment as a global cloud of signals, energies or so called events are at the end responsible for the way of life of a cell. In each single cell the mechanisms of life are triggered by the processing of the “events” of its environment and not by its genes.

Since “quantum physics” and the “Heisenberg uncertainty relation” we know today that such events are at last energy as eddies of quarks and photons, but we can define different types of events, also on the physical level. Around 3.5 billion years ago the first monads as bacilli and algae lived on the earth, 650 millions of years ago the multicellular organisms as trees and other plants were created as a more complex and more intelligent life, and since around only 100,000 years the today’s human is a united cell structure of 50 trillions of single cells where each cell is doing event processing on the base of its receptors of its cell membrane. So, a human being can allegedly process 120,000 events per second unconsciously (by the right side of the brain), but logically a human can only process around (I guess) 7 or a few information units at the same time (by the left side of the brain).

Against this background CEP is based on a very similar model. EPAs (event processing agents) are actually cells where event adaptors are the receptors of a cell membrane and the event processing logic based on an EPL (event processing language) are the effectors of a cell. EPNs (event processing networks) are actually a united multicellular structure and so on.

The Epigenetics explains how the environmental signals (events) control the activity of the genes. The primacy of the DNA is no longer valid, and the new found information flow is now called the “primacy of the environment”. Recent experiments of The Epigeneitcs have proved that our beliefs and thinking is energy in the sense of environmental signals. The Epigenetics found that all these kinds of environmental signals influence the regulating proteins which control the activity of the genes and that the global event cloud as environmental signals influences and changes the DNS (so called reverse transcriptase).

What is an individual?
According to the Epigenetics an individual is determined by the sum of its receptors in the cell membrane of all its 50 trillions of (specialized) cells. Each individual is unique because it is controlled or driven by the protein machines of its cells as a result of the received events (signals) of the global event cloud of the universe. The global event cloud does always exist and each event is an undestroyable energy which exists always and forever (see Unus Mundus and space-time continuum).

The Epigenetics explains an individual as an analogy of a broadcasting of television programs where the adjustment buttons are the receptors of the cell membranes which determine which program we receive in which manner. If we add or switch off receptors, we receive a different program or we see the same program differently. This can be understood as the incarnation of an individual. On the basis of such a model we can explain phenonemas like reincarnation or time travel as well.

Results of the recent Brain Research
On the basis of recent experiments of the Brain Research, researchers like Wolf Singer, Gerhard Roth et al. claim that a free will does not exist. They believe that their experiments have proven that the brain region which is responsible for a deliberate decision is only later activated when a signal or event is received while the protein machinery as the activity activator was already started “long” before. This cognition that there is no free will could be supported by the Epigenetics and the functionality of a cell membrane and its receptors and effectors/event adaptors and EPA’s as the basis of the whole protein machinery and as the motor of life.

“If you think you think you only think you think” versus “Cogito ergo sum” (Descartes) …”

For the U-CEP course/textbook I’m gathering some materials since some time which I’ll add to the U-CEP doc within the next days; here are some nice video lectures as a basis for U-CEP enhancements/projects, e.g. from Bruce Lipton, I like him as a great guy and great lecturer:

http://epigenetics.uni-saarland.de/en/home/ (German language only)
http://www.tonyb.freeyellow.com/id68.html
http://www.veoh.com/collection/AgriculturalNews/watch/v378752sbRFQa3F# (video)

Great to hear that TIBCO might support such U-CEP ideas, perhaps Larry Ellison or also Bill Gates would be interested in supporting such things … as an investment in the future

Part 4 in a series by James Odell on agent technologies and event processing. Part 1 covered Why Agent Technology for Event Processing, Part 2 was on the  Relationship between Agents and Events, and Part 3 was on What goes on inside an Agent? …

Conventional software objects can be thought of as passive, because they wait for a message before performing an operation. Once invoked, they execute their “method” and “rest” until the next message. A current trend in software architecture is to design objects that not only react to events but are also proactive. In UML 2.0, these are known as active objects; in the agent community, they are known as agents. Whether they are called active objects or agents, this new direction is radically changing how we design systems.

The Basic Properties of Agents

Figure 1 – Agents have degrees of autonomy, interactivity, and adaptivity

At a system level, 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 something that acts (c.f. an actor in some use case). However, for developing business and IT systems, such a definition may be too general. While an industry-standard definition of agent has yet to emerge, most agree that agents in an IT context are not useful without the following three important properties:

• Autonomous - capability to act without direct external intervention. It has some degree of self-control over its internal state and actions based on its own knowledge or rules.
• Interactive - communicates with the environment and other agents, typically via sensors or interfaces and events.
• Adaptive - capable of responding to other agents and/or its environment during interactions. An agent can also modify its behavior based on past events.

In short, a basic working definition useful for IT purposes is:
An agent is an autonomous entity that can adapt to and interact with its environment.

As illustrated in Fig. 1, agents can be autonomous, interactive, and adaptive - to various degrees. It is important to note that these are not “all or nothing” characteristics - there is no “agent minimum specification” qualification list! These three key agent properties will be discussed in more detail below.

Agents are Autonomous

Figure 2 – Degrees of autonomy

Agents can be thought of as autonomous because each is capable of governing its own behavior (to some extent). Autonomy is best characterized by degrees. At one extreme, an agent could be completely self-governing and self-contained. However, an agent that is fully self-sufficient and does not require the resources of, or interaction with, other entities is very rare-primarily because it would be unmanageably large and unnecessarily complex for any common role. At the other extreme, an agent that is barely able to perform the simplest self-management is of limited use in complex systems. Even traditional objects have some degree of autonomy within their methods.

An agent’s level of autonomy can be designed depending on its role. For example in Fig. 2, conventional objects are not completely dependent on outside resources-having some state and behavior of their own. However, they are traditionally simple in that they are far from being completely independent. Because a “supply-chain agent” is able to reach certain conclusions and make decisions on its own, it has more autonomy than an “object”. By their very nature, supply-chain agents require interactions with other entities to enable a fully functional supply-chain system, since one agent can not adequately support an entire organization’s supply-chain processing - interactions are also a characteristic for the class of agents called event processing agents (EPA). Even more autonomous are manager agents, because their role can involve a high degree of internal decision making through activities such as monitoring and delegation, which depend on outside resources.

Agents are Interactive

Figure 3 – Degrees of interaction in Agents

Interaction implies the ability to communicate with the environment and other entities. As illustrated in Fig. 3, interaction can also be expressed in degrees.

On one end of the scale, method invocations can be seen as the most basic form of interaction. More sophisticated would include those agents that can react to observable events within the environment. For example, food-gathering ants do not invoke methods on each other. Their interaction is indirect through the direct physical effects of their pheromones on the environment. Even more complex interactions are found where agents derive information - complex events - from multiple events over time. Here agents begin to act with “intelligence”. And then there are multiagent systems (MAS) where agents engage in multiple, parallel interactions with other agents. Here agents begin to act as a society.

Finally, the ability to interact becomes most complex when systems involving many heterogeneous agents can coordinate cooperatively and/or competitively through such mechanisms as negotiation and planning.

Agents are Adaptive

An agent is considered adaptive if it can respond to other agents and/or its environment. Entities that fail to adapt to the ever-changing world become extinct: organisms die, companies go out of business, and so forth. For an organization, adaptation enables the system to react effectively to changes in areas such as the market and business environment. For IT systems, adaptation enables systems to react appropriately to enable such effects as system balancing, integrity assurance, and self-healing. The goals and motivations for adaptation are around remaining competitive and useful, and deriving value. When designed properly, individual parts of systems can be empowered to change based on their environment and market conditions.

The primary forms of adaptivity include:

• Simple reaction rules - At a minimum, this means that an agent must be able to react to a simple stimulus-to make a direct, predetermined response to a particular event or environmental signal. Such a response is usually expressed by an IF-THEN form. Thermostats, robotic sensors, and simple events can fall into this category. From atoms to ants, the reactive mode is quite evident. A carbon atom has a rule that states in effect, “If I am alone, I will only bond with oxygen atoms.” Simple reactions can also include business decision rules - such as event-condition-action (ECA) rules.
• Inference rules - Beyond the simple reactive agent is the agent that can appear to reason by following chains of rules. For example, agents can react by making inferences and include patient-diagnosis agents, certain kinds of data-mining agents, and identifying complex events. Such inferences are computed by following a chain of inference rules, which can be described as goal-directed or data and event-driven.
• Learning - Learning is change that occurs during the lifetime of an agent and can take many forms. Popular learning techniques employ reinforcement learning include “credit assignment”, Bayesian and classifier rules, and neural networks. Examples of learning agents would be agents that can approve credit applications, analyze speech, or recognize and track targets.
• Evolution - Evolution is change that occurs over successive generations of agents. A primary technique for agent evolution usually involves genetic algorithms and genetic programming. Here, agents’ adaptive mechanisms can literally be “bred” to fit specific purposes. For example, operation plans, circuitry, and software programs can prove to be more optimal that any product that a human can make in a reasonable amount of time.

Other Agent Properties

In the sections above, three key agent properties were discussed: autonomy, interactivity, and adaptivity. These properties are important because they are essential for agents deployed by IT systems. However, agents may possess various combinations of other properties whose usefulness depends on the application requirements and the agent designer. Here, agent characteristics may include being:

• Sociable - interaction that is marked by friendliness or pleasant social relations, that is, where the agent is affable, companionable, or friendly.
• Mobile - able to transport itself from one environment to another, and geo-aware.
• Proxy - may act on behalf of someone or something, that is, acting in the interest of, as a representative of, or for the benefit of some other entity.
• Intelligent - state is formalized by knowledge (e.g., beliefs, goals, plans, assumptions) and interacts with other agents using symbolic language.
• Rational - able to choose an action based on internal goals and the knowledge that a particular action will bring it closer to its goals.
• Temporally continuous - is a continuously running process.
• Credible - believable personality and emotional state.
• Transparent and accountable - must be transparent when required, yet must provide a log of its activities upon demand.
• Coordinative - able to perform some activity in a shared environment with other agents. Activities are often coordinated via plans, workflows, or some other process management mechanism.
• Cooperative - able to coordinate with other agents to achieve a common purpose; non-antagonistic agents that succeed or fail together. (Collaboration is another term used synonymously with cooperation.)
• Competitive - able to coordinate with other agents such that the success of one agent implies the failure of others (the opposite of cooperative).
• Rugged - able to deal with errors and incomplete data robustly.
• Trustworthy - adheres to Laws of Robotics and is truthful.

Part 3 in a series by James Odell on agent technologies and event processing. Part 1 covered Why Agent Technology for Event Processing, and Part 2 covered the Relationship between Agents and Events. Now over to Jim…

Agents are autonomous entities that can adapt to and interact with their environment. To accomplish this, agents must have some means by which they can perceive their environment and act upon those perceptions.

An agent can be a machine, a piece of software, or a variety of other things (even a person). The basic dictionary definition of agent is something that acts. However, for developing business and IT systems, such a definition is too general. While an industry-standard definition of agent has not yet emerged, most agree that agents deployed for IT systems are not useful without the following three important properties:

• Autonomous - is capable acting without direct external intervention. It has some degree of control over its internal state and actions based on its own experiences.
• Interactive - communicates with other agents and the environment.
• Adaptive - able to change its behavior based on its goals, change in state, and experience.

Agent as a black box

Figure 1 - An agent and its environment

At its simplest, each agent can be thought of as an interacting black-box process, where no indication of an agent’s internal structure and behavior is given other than that which is visible from outside the agent. Figure 1 illustrates that agents have input from, and output to, the environment - i.e., it receives and emits events. An agent’s environment can be thought of as everything outside of the agent. For robotic agents, the environment would consist of the terrain, the constraints of motion and control, and other agents. For software agents, the environment would consist of the hosting platform, its operating systems and supporting middleware, and other agents.

Input can be whatever the agent “perceives,” such as messages, requests, commands, and other events. Based on such input, the agent can decide how to act, which typically results in some output from the agent, such as communicating with, or making a change to, its environment. For instance, our Robotic agent could receive a move command, and then change its state through movement (events). An Inventory agent could receive a request for the quantity-on-hand for a given commodity, causing it to determine the requested quantity and send a response event to the requestor. The Inventory agent would also receive notification events regarding inventory being removed and sent to a customer. The agent process would then recompute the quantity-on-hand and decide if a reorder point has been reached, and if so, would send out requests-for-bid to appropriate suppliers.

Agent processing overview

Figure 2 – The basic internal architecture of an agent

For an agent to interact with its environment, it must be able to not only detect and affect its environment, but also to understand what it is detecting, decide an appropriate response, and to act on it. The internal structure of an agent can be visualized as illustrated in Figure 2.

State

Just like objects, agents can have a form of memory, referred to here simply as state. State includes the data that it needs to operate and is maintained or can accessible in some manner (such as, via a database or automated blackboard) by the agent.

For example, the Inventory agent would need to maintain information such as the reorder point for a particular product or the algorithm needed to compute the reorder point. The agent might also maintain the list of valid product vendors that it can contact for reordering-or at least know where the information might be found, or which other agent it can delegate that request to. The agent could even make inferences about its own state or the state of other entities in its environment. State, then, can be metaphorically interpreted as anything that the agent can “know” or “believe” about itself or its environment.

Detectors

Detectors provide the agent’s interface to the environment. They receive the input events that are of interest the agent. Detectors can both receive input sent to them (i.e. “push” model) or actively scan the environment for it (i.e. “pull” model). Detectors can receive simple messages and event notifications, or they can scan message logs or monitor event occurrences. In particular, event-monitoring agents (in event-driven architectures) may be specialized to recognize particular kinds of state changes in the environment.

For example, master data agents could watch for certain kinds of changes in a database such as metamodel modifications, customer-address changes, or even the database going offline. If any of these events were detected, the agent could notify other agents that can react appropriately, such as the system monitor agent that notifies the DBA. In event-driven architectures (EDA), this is particularly useful. Our robotic agents may employ such sensors as cameras, global positioning hardware, or infrared devices for detectors, and directly process and interpret the associated images and event streams.

Parse input

Once the detector receives input, the agent needs to analyze and “understand” the input. This action typically involves recognition, normalization, and exception handling. For conventional object-oriented software, there is virtually no parsing: the OO “signature’s” the first parameter identifies the object, the second specifies the requested operations, and the remaining input contains the data required for the operation execution. Because the signature syntax is already defined in this manner, the message does not need to go through any “decide action” step. Instead, it goes immediately to invoke its specified method.

In a system with a more complex style of input, the OO approach cannot provide a satisfactory solution. For example, some IT agents need to process complex syntax and receive input in one or more languages, such as SQL, Prolog, BPEL4WS, BPML, or ebXML. They may need to understand complex ontologies expressed in OWL before any further action can be determined against some RDF data. For complex-event-processing agents, this parsing can mean identifying event patterns in the input. Such event pattern recognition is important for agents, especially those that need to recognize many potential new state situations (e.g., self-healing systems).

Granted, activities like parsing require greater complexity than a traditional object. In fact, not all agents will require such sophisticated behaviors. Yet, when system requirements demand richer behavioral control at execution time, agents need to be able to accomplish what traditional objects cannot. Activities like parsing or accepting rule updates extends the notion of the semantic net to enabling the semantic approach to system interaction, in general.

Decide action

As suggested earlier, traditional OO recommends that the method requested of an object be determined before a message is sent to the object, because each object class defines separate methods, one for each kind of message “signature.” If the number of possible methods is tangible, this is not a problem; for those situations requiring hundreds or thousands of possibilities, such an approach is impractical.

For example, insurance companies have hundreds of ways of rating a policy; retailers and shipping companies have an equally large number of rules and procedures for pricing a product or service. To support this need in an agile and adaptive manner, the agent also needs the ability to determine the appropriate method after it receives a request for service. In this way, a Policy agent can decide on the appropriate method to rate a policy based on the requestor’s needs. Order agents can decide the appropriate pricing algorithm when the customer submits order.

Another function within the Decide Action step could be to determine the appropriate goal for further consideration. For example, an Inventory agent would detect each time a product was pulled from a warehouse bin, and for each such instance it might need to first decide if the product should be reordered or, if it is selling too slowly, discontinue the product altogether. Each of these goals requires a different process. One might involve sending out and processing bids from other agents to refill the bin; the other might notify customer agents that the product will no longer be available, and await responses.

The Decide Action process might involve a high degree of complex processing in its own right. Can this be accomplished using an OO approach? Absolutely. However, some agent platforms have mechanisms that support higher order models of decisions directly- for example using rule engines instead of having the programmer do extra work in design, construction, testing, and maintenance.

Invoke action

Once selected, the appropriate action needs to be invoked. The action execution may involve actions internal to the agent, in which case, message events can be sent directly to the agent’s own detectors. If the action involves other agents, the message events need to be sent to them. The agent controls its autonomy by using its own resources or having them provided by other agents. It determines what it can do and what it must delegate. In this sense, the agent manages itself-rather than just being managed.

In addition, some agents can determine when their internal actions are not functioning as expected. The agent can also communicate to itself that the situation needs to be remedied-by sending itself a message and letting some Decide Action step determine which action should be taken next. In other words, the agent can have its own self-aware processes. In a business process management system, such mechanisms can be handled in a distributed manner using events and agents, rather than by some centralized controller that will not scale under large processing volumes.

Effectors

When messages need to be sent or events posted outside the agent, effectors are the connection with the agent’s environment. It is the mechanism an agent uses to interact with and mobilize within the environment. This could involve sending messages though a message bus or activating a hardware device such as a printer or robot arm.

Agents can be multiprocessing

Figure 3 – Concurrent processing within the agent is possible

Agents can be single threaded or designed to process input concurrently. (Figure 3) Agents that can support concurrency might also have a process controller that coordinates the various internal actions in some manner.

Reasoning, planning, and scheduling

A common approach for agents can involve reasoning, planning, and scheduling. (Figure 4) In this approach, an agent can determine the appropriate action by having a reasoner step consider what it knows about its state and the state of its environment (including that of the service requestor). Additionally, the agent reasoner can identify the appropriate goals for acting based on the detected input and state knowledge. Here, the agent may optionally weigh the importance of certain goals (when there are several or conflicting goals to choose from).

Figure 4 – Determining the appropriate action can involve reasoning, planning, and scheduling

For example, a Scheduling agent may have a goal to ensure that all the tasks in its care are executed on time. Another goal might be that certain priorities must be given to important tasks. The two goals, however, may conflict when priority tasks cause the delay of other tasks. Here, the agent may have to weigh the cost of both and determine which service it intends to perform under a given constraint.

A planner then determines the actual steps needed to execute the agent’s intension. For example, the scheduling agent may need to ensure a particular product is created for given order. The agent may need a make-or-buy decision resulting in a process that either fabricates the product in-house or purchases a fabricated item from an external source. Some agent planners dynamically assemble the planned set of steps to fit each occasion; others have a library of prefabricated processes from which to choose.

The planned process is then sent to the agent’s scheduler to determine which resources will be assigned and when the process will be scheduled [see note 1].  On top of this, an agent may also employ a coordinator that ensures that the agent’s concurrent processing works harmoniously: managing roles and conflicts, as well as optimizing the overall functioning of the agent.

What’s next?

Figure 5 – Cell composition

The next “CEP and Agents” blog entry will address agent composition, in general. This blog post surveyed the kinds of functionality that agents can possess internally; the next blog will explore how agent functionality can be physically rendered. For example, every cell in your body consists of many components, such as those in Figure 5, right.

Using nature as an analogy, then, agents can have multiple internal components that provide it overall behavior - just like those illustrated in Figure 4. Furthermore, some of the cell components can, themselves, be cells in their own right. For example, Mitochondrion are cells, yet they live within other cells for the purpose providing energy to its host. Similarly, the internal functions for the agent illustrated in Figure 4, may be agents in their own right. For example, the Detector capability in Figure 4 may be implemented as a TIBCO Hawk agent (which specializes in system event detection). In other words, the internal agent functionality can be provided by a combination of mechanisms, such as program modules, components, or first class agents.

Also, by considering composition in the opposite direction, we find multicellular forms of life such as sea coral, bodily organs and so on. And if we continue in this direction, we find even more large and intricate systems, including humans, human social groups and organizations, and ecosystems. The same analogy applies to agents. As we just learned, an agent can consist of other agents. By continuing this pattern, such grouping is a way of progressively modularizing multiple agents into structures such as teams, organizations, societies - and, yes, even agent ecosystems.

____________________________

[Note 1: Agents using this approach are sometimes referred to as "BDI" agents, because they employ beliefs, desires, and intentions. Beliefs refer to what the agent "believes" the state of its environment and other agents to be; desires basically refer to the goals the agent could attempt to achieve, and intentions refers to the set of goals the agent actually intends to achieve under a given circumstances.]

Part 2 in a series by James Odell on agent technologies and event processing. Part 1 covered Why Agent Technology for Event Processing. Now over to Jim…

Let’s start with the situation where a tree falls in the forest when no one is there to see or hear it. If there is no mechanism to sense, notify, or record the occurrence of the tree’s state change, is there really an event? Since no knowledge of the event will exist, it will be, well, a non-event.

However, we don’t always need people to serve as event processors. Off-the-shelf sensors and traditional software could easily provide event processors that can sense, notify, or record such events. So, why do we need agent technology here? The answer centers on the number and complexity of events that need to be processed. Simple events that trigger a process can be supported by conventional means.

However, what if we change our perspective from a simple tree-falling-in-the-forest to our buzzing world of daily business communications. Business communications are numerous and often complex. One communication could be monitored by thousands, and then filtered, analyzed, and aggregated with other communications - which in turn can become noteworthy events for others, and so on. As this continues to grow in size and complexity, our ability to understand, analyze, and control can quickly go beyond the abilities of conventional technology. Here is where agents can step in.

For example, the figure right from Roy Schulte (Gartner) is a token representation of a complex event processing environment. On the left, you can see an even processing agent (EPA) receiving two events. As a result of these two events, the EPA may determine that another event should (or should not) occur. For instance, a Buy and Sell event for a particular customer’s stock might have occurred. If the Sell event occurred prior to the Buy, trading-error event could be generated. This event might be one of three events that another EPA was monitoring, resulting in another event. Which, in turn, are monitored by another EPA, resulting in one of perhaps two events, depending on results of its analysis.

So, why use agents? Why not use a large brain-like approach that would solve the event processing centrally, such as using an expert system or neural network? You could - up to a point. However, when your CEP starts requiring thousands of rules to be processed, maintaining a single expert system would quickly become unwieldy to maintain and test. So, another approach is to divide the expert systems into smaller, manageable-yet federated-expert systems. This would be tangible up to a dozen or so expert systems, but what happens then? Would you understand and manage them? If your expert systems each had a particular business-based theme, you might be able to manage them because there would be some rhyme or reason for the rule grouping. The result, then, is a set of smaller yet federated set of event-processing business-organized “brains.” But again, as each expert system becomes too large, it too must be partitioned in multiple, business-based, smaller ones.

So, where does this all stop? As an organization - particularly a global one - expends or changes, this constant divide-and-conquer approach will not stop. The agent approach, then, offers a more sane alternative: start with small business-based units to begin with.

Agents are autonomous and interactive entities that are defined on the basis of a specific need. They may play multiple roles, learn, and evolve if need be. They may behave socially and self-organize. In other words, they can be as adaptable as required to be able to service specialized needs and communicate with other agents. Just like social beings, they can have the ability to understand, analyze, and control their specific niche.

Agents, then, are a way to “divide and conquer” the problem, much as humans (and other organisms) do. It’s still software, but it’s modularized on a business-needs basis, and can be thought of as small-granularity “intelligent objects.” They can mimic social configurations and interactions and can scale and perform as an organization. Leveraging agents in this manner, then, enables event processing that is concurrent and distributed. Does this sound like the living, breathing world around us? It should. This is why agent-based applications are able to better manage complex systems and adapt to change.

So, what is the relationship between agents and events? Agents enable event processing networks to scale in size and complexity — and be designed in a more human-understandable manner. Agents can be used for monitoring, filtering, analyzing, and aggregating events - before notifying other agents. As Paul Vincent indicated in his earlier blogs, agents can also be used within the CEP middleware infrastructure, combining source event distribution with agent communication.

Over the next few weeks James Odell, known for his work on OO, UML and agents, will be offering some thoughts on agent technologies on this CEP Blog. Over to Jim…

The notion of event processing agents (EPAs) is quickly becoming a topic that more and more organizations are considering. We’ve been building systems that employ event processing without agents for quite some time. So, why agents and why now?

One of the primary reasons is that we are no longer in the era of mainframe computing, when both companies and applications were typically command-and-control oriented and organized in vertical silos. With the combination of the Internet, fiber optics, and PCs, the business and technology playing field has been flattened. No longer primarily top down, it has changed to more side by side-as individuals, small groups, and organizations interact around the world. In other words, the events around us are based on complex web of activity that is less command and control and more horizontal connecting, collaborating, and competing.

When the events among requesters and providers are few and change is not an issue, agents are not needed and conventional IT techniques can be employed. However, when the links require complex, dynamic binding and are subject to rapid change, agent-based approaches should be considered. Prior to the demand for global collaboration, we developed a centralized controller to ensure that all interactions would be appropriately managed. Now, this is no longer possible. The world is too big and a central bottleneck would paralyze the effort. As a result, the access techniques now require a more horizontal style of interaction-rather than one that is centrally administered.

Agent technology is a primary enabler to support this new direction. In fact, without agent technology, our current technology will not scale to support the ever-increasing global interaction. More importantly, it will enable us to create and support a whole class of IT applications and approaches that we previously could not have developed-this especially includes complex event processing.

In the next installment, I will address the question: “What is the relationship between agents and events?”