Brad Rhodes; 118,500 +118,500-US; 49 Arthur Boatman; 118,000 +118,000-50. Caesars also owns the World Series of Poker® and the London Clubs International. Avery Bass won the opening event of the later season of the World Series of Poker Circuit this last weekend. The tournament, which took place at the Palm Beach Kennel Club in West Palm Beach, Florida, begins the 11th season of the WSOPC. Avery Bass won his first live tournament, which gave him $95,000 in winnings for the event. Brian Locklar came in second place and finished with $58,760. Alexey Sidorenko. Marian Steinbach. เติมเงินไทยฟรี เกมส์ poker texas.
Collab97 project proposal: The Direction Bump Brad Rhodes (rhodes@media.mit.edu) and Seum-Lim Gan (gan@media.mit.edu) The idea: Create a belt, armband, ankle-bracelet, or other 'encircling' clothing that gives tactile feedback to convey direction. There are two kinds of devices possible for this project, depending on the hardware available.
NOTE: this is an HTML formatted version of the paper.Please go to the paper's homepagefor more printer-friendly formats.
Nelson Minar, Matthew Gray, Oliver Roup, Raffi Krikorian, and Pattie Maes
MIT Media Lab E15-305 20 Ames Street Cambridge, MA 02139 USA
<nelson@media.mit.edu>
http://hive.media.mit.edu/
August 3, 1999
Appearing in ASA/MA '99
Abstract:
Hive is a distributed agents platform, a decentralized system forbuilding applications by networking local system resources. This paperpresents the architecture of Hive, concentrating on the idea of an``ecology of distributed agents' and its implementation in apractical Java based system. Hive provides ad-hoc agent interaction,ontologies of agent capabilities, mobile agents, and a graphicalinterface to the distributed system. We are applying Hive to theproblems of networking ``Things That Think,' putting computation andcommunication in everyday places such as your shoes, your kitchen, oryour own body. TTT shares the challenges and potentials of ubiquitouscomputing and embedded network applications. We have found that theflexibility of a distributed agents architecture is well suited forthis application domain, enabling us to easily build applications andto reconfigure our systems on the fly. Hive enables us to make ourenvironment and network more alive.This paper is dedicated to the memory ofMark Weiser, a visionary and a guide.
Computation is changing. Computers are no longer isolated numberfactories; they are on our desks, on our wrists, in our pockets, andembedded in devices all over our homes and offices. Computers areconstantly communicating with each other via wireless networks, LANs,and the Internet. This new reality of computation demands newparadigms for building computer systems.
We believe that software agents are an important abstraction forbuilding distributed systems. Software agents -- small, autonomous,self-describing programs -- are an excellent building block forcomplex open-ended networked applications. We have created Hive, asoftware system implementing an ecology of distributed agents. We areapplying Hive to creating applications for our new networked computerreality, focusing on connecting embedded computers, or Things ThatThink (TTT).
The design of Hive has been strongly influenced by theWorld Wide Web. We take two lessons from the success of the Web: theimportance of decentralized systems and the value of simpleabstractions. The Web is deeply decentralized in that any web page canbe linked to any other without any central administration; similarly,Hive systems are built entirely out of peer-to-peer relationshipsbetween agents. The key Web abstraction, the web page, is mirrored inHive by the software agent. But while the Web is a distributed systemfor static data, Hive is for dynamic computation. We wish to make theInternet alive.
1.1 Ecologies of distributed agents
Our metaphor for building networked systems is the ecology ofdistributed agents [21]. In an ecology ofagents, an application is created out of the interaction of multipleagents across a network. Each agent is located in a particular place(in Hive, called a cell), and uses various local resources(shadows). Agents communicate with each other to share informationand access to resources. An application is made from thecommunications and actions of agents.
Why do we use agents? From a programmer's perspective, a Hive agent isjust a distributed object with an execution thread. But in Hive agentsare more than just objects, they are the building block of an activedistributed system. Agents provide a conceptual wrapper for severaluseful ideas:
- Agents are autonomous: they can be sent into a system andentrusted to carry out goals.
- Agents are proactive: they encapsulate computational activity.
- Agents are self-describing: anontology of agent capabilities can be used to describe and discover availableservices.
- Agents can interact: they can work together to complete a task.
- Agents can be mobile: mobile agents provide a simple abstraction forcomplex, dynamically distributed systems.
The ecology of distributed agents is a decentralized system. Webelieve decentralization is essential to allow a system to grow.Decentralization comes at a cost: agents are responsible for locatingthe resources they need, finding each other, and negotiating theirrelationships. Hosts are responsible for protecting themselves fromunwanted agents and keeping their own consistency. And there is nosingle place one can point to and say ``this is the center of thesystem, this is where it comes together, this is how we know that itis working correctly.' Such challenges are the reality of distributedsystems today. The details of how we manage these problems aredescribed throughout this paper.
Hive is an embodiment of an ecology of distributed agents. This paperdescribes specifics of how Hive is implemented, the applications wehave built with Hive, and the lessons we have learned from testingHive in real systems. But first, we introduce our primary applicationdomain.
1.2 Things That Think
The goal of the Things That Think project at the Media Lab is to takethe power of computers and networks and put them into our everydayobjects. TTT enhances the physical world with computation andcommunication. TTT makes our computer networks more complex andcapable as every room, appliance, and even light socket begins to``think.' A full explication of Things That Think is beyond the scopeof this paper; a detailed description is available in [12].
This agenda is shared by many researchers. Mark Weiser details relatedideas under the name ``ubiquitous computing' [32]. In theconsumer world, embedded computers are quite common and technologiessuch as Bluetooth are bringing networking to consumer devices. Toysare a leader of this trend, with networked toys like MicrosoftActimates or Furby and industry initiatives such as Intel Play[35]. And the computer industry is tackling the problemsof networked embedded systems applications with technologies such asInferno [9] and Jini [2].
Ubiquitous embedded networking presents a variety of challenges forapplication infrastructures. Devices are scattered all over thenetwork, so the system must be fully distributed. Administrativeoverhead has to be low, meaning the system cannot be too centralized.New devices need to easily be added, requiring an open architecture.Finally, people will want to add new devices and create newapplications, doing things with the system that cannot be foreseen byits designers. The system must be flexible.
An ecology of distributed agents is a good match for these requirements.Hive's use of agent ontologies and mobility makes it flexible. Agentdescriptions allow new capabilities to be announced, discovered, andused. Mobile code allows for parts of the system to be reprogrammeddynamically, for the network itself to evolve as necessary.
Hive is a good infrastructure for TTT, and TTT is a good problem forHive. It is not enough to build an agent system in the abstract; thesystem has to be tested, used, understood. Building TTT applicationswith Hive has helped us validate its design principles and taught usmany lessons about the design of agent-based distributed systems.
Hive consists of three components: cells, shadows, and agents. TheHive network is a decentralized collection of cells. A Hive cellis the analog to a web server, a program running on a specificcomputer with a published network address. Each cell contains a set oflocal resources called shadows that encapsulate capabilities such as a screen display or a digital camera. Eachcell is also host to many agents that use local resources andcommunicate with each other. By analogy to aconventional operating system, a cell is like a kernel, shadows arelike device drivers, and agents are like processes.
A schematic diagram of the Hive architecture is presented in figure1. Hive is a set of Java libraries; currently, thesystem consists of roughly 280 classes in 24,000 lines of code, halfof which are generic infrastructure and half specific code for about30 devices and 60 agents. In addition to the basic Java libraries,Hive makes extensive use of Java Remote Method Invocation (RMI) andserialization for agent communication and mobility. For ontologysupport Hive uses the SiRPAC RDF library [25].
2.1 Cells: nodes in the decentralized network
The Hive cell is a program that participates in the network. Cellsperform two primary tasks: hosting software agents and managing accessto local resources through shadows. The ideal model would place a Hivecell on every device. However, Hive cells require a fair amount ofCPU power and memory, and so they currently run on desktop-sizedcomputers that proxy for several devices. A typical cell has severaldevices providing input resources (such as a motion sensor, camera, ordigital tag reader) and output resources (a computer display, a smallrobot, or a speaker).
Hive has a location dependent model of a distributed system.Hive cells are not all the same: each cell has a specific set ofshadows and a specific population of agents. If one wants access to aparticular device, one has to contact an agent on the cell that hasaccess to that device's shadow. This model is in contrast to manydistributed systems that try to abstract away the concept of location.Hive explicitly uses the locations of shadows and agents to helporganize and partition the system. Things have places.
Hive cells are created as necessary to represent devices, and areintended to be long-lived processes. Each Hive cell is an equal peerin the network. Agents on one cell can communicate with agents on anyother for a completely free-form, decentralized system. Federations ofHive cells are formed ad-hoc. Hive cells typically run a ``server listagent' that contacts a registry to maintain membership in the globalHive network, but cells are free to arrange for their own federationsas needed.
2.2 Shadows: local resources
A Hive cell by itself is simply a shell; a cell is interesting becauseof the shadows it provides. The term `shadow' suggests its role ofencapsulating a local resource. Physical devices are `shadowed' intothe Hive cell. For example, a Hive cell may have a digital cameraplugged into it. The camera's shadow provides a software interface tothe hardware, with methods such as takePicture() andsetBrightness(). If an agent wants to directly use a camera, itmoves to the camera's cell, asks the cell for the camera shadow, andthen invokes the shadow with standard Java method calls.
Shadows are simple, they are nothing but an API to access a specificresource. However, the shadow abstraction is very useful forstructuring a system. Shadows are the static part of a Hive cell; asystem designer writes a shadow once, encapsulating all of a device'sbehavior, and then freezes that code in place. The flexibility of thesystem comes from the mobile agents; the shadows provide the staticlayer which the agents access.
Shadows also provide the place for a Hive cell to enforce asecurity or resource control policy. Shadows are trusted code. Shadowsare not mobile, and they do not communicate directly over the network.To export a device's functionality off the local cell, an agent mustmediate between the shadow and the network.
2.3 Agents: active computation
If shadows are the fixed, static, local component of the system, thenagents are the active, dynamic, networked aspect. Hive agent sembodythe network interface and policy for resources. Technically, a Hiveagent is a combination of a Java object, an execution thread, aremote interface for network communication, and a self-description.These four simple pieces together create an agent, a full-fledgedautonomous process in the distributed system.Agents live on specific cells, accessing shadows for the resourcesthey need. Agents export selected functionality to the network andcommunicate with each other to share those functions. For example, acamera agent can export the picture taking functionality of the camerashadow to remote agents. An image displayer agent can then invoke thismethod over the network, implementing a simple remote picture takingapplication. Hive applications are built out of a collection ofinteracting agents. Agent interactions, descriptions, and mobility arediscussed in section 3.
2.4 User interface
Hive provides a graphical user interface to the distributed system. InHive, the computer display is simply another shadow; any agent candraw on the screen by sending a Java graphical component to theappropriate shadow. The Hive user interface is implemented as anagent. The AWTUIAgent provides a graph view of the state of thesystem and a control interface by communicating with system agentssuch as the ServerControlAgent and ServerInfoAgent. By usingagents for system tasks, Hive itself benefits from the distributedagents approach.
Figure 2:Hive Camera Application
A screenshot of the user interface is shown in figure2. The user interface displays two major aspects of thesystem: agents and the connections between agents. Each agent isrepresented as an icon. The agents at left are a simple cameraapplication (described below), the agents at right are systemmanagement agents. Agent communication paths are shown as arrowsbetween icons. The visualization is dynamic -- as agents message eachother, messages are shown as animations along the connection arrows.The interface can display multiple cells; this example shows two.
The user interface is not for information, it is also for control. Newagents can be created from the drop-down menus. Agents can beconnected to each other by drawing lines between them. And agents canbe moved or killed by popping up their menus. The Hive user interfacemakes it easy for users to experiment with agent populations andcreate new applications with the stroke of a mouse.
2.5 A simple example
The image shown in section 2 is from a basicapplication we use to demonstrate the Hive system. The core of thisexample consists of three agents: an on-screen button (upper left), adigital camera (middle left), and an on-screen image display (lowerleft). The application is simple: the user clicks the button, thecamera takes a picture, and the picture is displayed on screen.
Three agents work together to build this application: the button, thecamera, and the display. The button and display both send graphicalcomponents to the cell's computer screen. The camera shadow uses alocal resource, a digital camera. When the camera agent is createdit asks the cell for access to the camera shadow; if all is well,access is granted and the agent can take pictures and send them overthe network.
Once all three agents are established, all that is left is to connectthem. The image display agent connects to the camera agent, and thecamera agent connects to the button agent. When a user clicks on thebutton, the button agent sends an event to the camera agent. Thecamera agent interprets this as a command to take a picture and sendsan event to the display agent with the image embedded as data. In thisexample, the camera agent is on a second computer; the agents arecommunicating over the network to create the application.
This distributed application is not itself new. What makes Hiveinteresting is the simplicity and flexibility with which applicationslike this can be built. New applications can easily be built byconnecting existing agents. An agent that detects the motion of a dooropening can connect to the camera to get pictures of everyone whocomes into the room. A face recognition agent can use the camera todiscover the names of visitors. Or an agent could scour the Hivenetwork looking for camera agents, to build a photo gallery of anentire building. Finally, mobile agents can be dropped anywhere intothe network, dynamically upgrading and changing pieces of theapplication. All of this flexibility can be used any pre-planning andwithout altering any other agent's code. This is the power of anecology of distributed agents.
Hive agents live out their lives on cells, possibly traveling thenetwork. Agent interaction is ad-hoc, based on simple distributedobject techniques. Hive agents have a rich ontological basis, usingboth the Java type system and the Resource Description Framework[19] as description languages. While creating a practical systemto network Things That Think we have tried to balance working on deepagent research questions against creating simple, useful software foreveryday programmers. Hive draws techniques from many parts of agentresearch including agent autonomy, mobility, multi-agent interaction,and agent ontologies. For each of these fields, we have tried toextract the most essential pieces, bypassing complexities and unsolvedproblems.
3.1 Agent anatomy
All Hive agents are rooted in a common agent base class. We have triedto adopt a minimal approach to designing Hive, only adding fields andmethods when we are absolutely sure we need them. We have drawninspiration from other mobile agent systems such as Aglets[17], particularly for the agent lifecycle, but have tried tosimplify where possible.
Every agent stores two fields: the cell the agent is living on and apointer to a ``description' object that is used for semanticdescription. In addition, application agent subclasses typically haveadditional internal state for their own computation.
The agent class is a subclass of UnicastRemoteObject, the basisof remote objects in RMI. This class allows for the methods of anagent to be executed remotely. Choosing RMI as the agent communicationmechanism simplifies the Hive architecture: agents are simply remoteobjects, we do not require any extra agent communication system. Thecost for this simplicity is control; all management of agentcommunication has to be done within RMI. Hive does not have explicitcontrol over agent messaging, placing the responsibility forunderstanding messages and deciding whether to act on them with theagents themselves.
3.2 Agent interaction
Agent interaction in Hive is completely ad-hoc. We make norequirements for agent communication, it is up to individual agents todecide how to talk to each other. Agent communication occurs via RMI'sremote method invocation, allowing for agents to synchronously callmethods on each other. We have added asynchronous calls to RMI so thatagents can decouple their interactions. Java's strong typingsyntactically structures agent communication, but agents are free todefine their own semantics.
Each agent has two types: the true type of the agent's object, asubclass of AgentImpl, and the agent's remote interface, asubtype of Agent. This duality is common in RPC-like systems.While initially it might seem a nuisance to write two types for everyagent, the split between an agent's remote interface and its localimplementation is useful. In particular, agents have bookkeeping andadministrative methods that would be inappropriate other agents tocall. Because agents can only access each other's remote interfaces,sensitive methods are protected by Java's type system. And in practicemany agents can simply inherit their remote interface, eliminating theneed to define one.
The base agent interface has several methods that can be calledremotely. Some methods are informational, such as getServer() andgetDescription(). Other remote methods are administrative, suchas diePlease(). This may seem a strange method to make remotelyaccessible, but it allows agents to manage other agents. And while anyagent can ask another to die, the remote agent does not necessarilyhave to comply.
Finally, agents have remote methods for managing abstract``connections.' An agent can ask another to connectTo() ordisconnectFrom() an agent, or ask it tolistAllConnections(). As with all aspects of an agent's interface,these methods are purely advisory. Agents are free to define their ownmeaning of ``connection' and to ignore requests. We have found thatseveral simple communication patterns, particularly eventpublish/subscribe, are broadly useful. For example, EventListeningAgentsconnect to EventSendingAgents, following the Jini DistributedEvent specification [2] to pass event objects around thesystem.
In addition to these standard agent methods, application agents candefine extra methods in their interfaces. For example, Hive usesagents to manage system functions. A cell's ServerControlAgenthas remote methods such as moveAgent() or shutDownServer().Other agents (such as the user interface agent) communicate with thisagent to control remote cells. The ServerControlAgent isresponsible for deciding what to do when these methods are invoked;agents implement their own security policy.
3.3 Syntactic ontology
Hive relies on the ability of agents to describe themselves to makead-hoc agent interaction coherent. Every agent in Hive is described interms of two orthogonal ontologies: syntactic and semantic. Hive cellsprovide a query service based on these descriptions so that agents canfind each other. For example, a remote agent can ask for a list of allagents that are ``EventSendingAgents that can provide me withmotion data in room E15-305.'
The syntactic ontology of agents in Hive comes for free from Java. Anagent's syntactic description is simply its Java type. While this mayseem trivial, its usefulness should not be overlooked. The type of anobject says much about its capabilities with reference to awell-established and well-understood ontology, the class hierarchy of thesystem. Given a reference to an agent, it is easy to learn which typesthat it supports and, therefore, the messages it understands. ThequeryAgents() interface on a Hive cell allows the requester tolist the types it is looking for.
There are several hard problems we have not solved with the syntacticontology. Two classes might have the same name but in fact bedifferent versions or different types entirely. Hive can not guaranteeconsistency. Mobile code means that the syntactic ontology of Hive isopen-ended; if a new agent class comes into the Hive network, otheragents might not know about that type to query for it or message toit. We do not see any way to solve these problem without answeringfundamental epistemological questions. In keeping with the practicalbent of the Hive system we have chosen to defer working on theseissues. So far, they have not hampered our ability to create usefulsystems. We believe that in building practical applications people canengineer their agents to work around these problems, by eithercreating an ontology for a project or following consensus practice.
3.4 Semantic ontology
A syntactic ontology is not enough to describe agents, there aremany bits of information about an agent that do not fit into a rigidclass hierarchy. For instance, the fact that an agent is representinga device ``in room E15-305' is not easy to codify syntactically. Onecould add a getRoom() method to the agent as part of aRoomIdentifying interface, but then that method would make nosense on many agents that do not have a physical location.
The limitations of Java class hierarchies for semantic description arecompounded by the fact that an agent might want to assume differentcapabilities at runtime. For example, an agent that filters eventstreams might need to assume many different identities depending onwhat event source it is connected to. But in Java one cannot addinterfaces to an object at runtime, the type of an object is static.
To circumvent these limitations, Hive uses a second orthogonalontology to describe ``semantic' information about agents. Thisontology utilizes the Resource Description Framework (RDF) [19],itself based on XML [5]. RDF provides a structured way toattach nouns and verbs to agents. For example, an agent's semanticdescription might state its physical location, a human readablenickname, the owner of the device it is using, and a description ofthe meaning of its data. Hive agents carry an RDFdescription, available by calling getDescription(). Other agentscan inspect this description to learn about the agent, and the cellquery interface supports matching across sets of RDF descriptions.Agents are free to change their descriptions at runtime.
Our semantic ontology does not solve any deep philosophical problems,but it allows application designers to express their own solutions. Weexpect that application designers will develop their own schemas tomake agent communication semantically consistent. These schemas may becompletely ad-hoc or may be strictly defined by an SGML DTD and a DDMLschema [4]. We expect users to collaboratively defineschema by common consensus while building Hive systems. As the Hivenetwork grows, ontologies should emerge from common practice.
3.5 Mobility
A final aspect of Hive agents is that they are mobile. Hive mobilityhas two portions: mobile code and mobile agents. Mobile code enablesthe software on each Hive cell to be updated dynamically. Mobileagents build on mobile code, allowing agents to move themselves aroundthe Hive network. Hive agents have weak mobility [3]: theagent must make its own arrangements for preserving its executionstate on transport. We believe strong mobility is preferable but iscurrently too difficult to implement in Java. There are a couple ofexperimental systems that achieve strong mobility by modifying theJavaVM [14] [22], but a standardmechanism has yet to be defined.
Some of the advantages of mobile agents are well understood[7] [18]. If an agent is using lots ofbandwidth or needs low-latency access to a resource, then it can bemore efficient for the agent to move to the resource's cell than tocommunicate with it (through another agent) over the network. And if aHive cell has unreliable network access, moving agents to a morestable Hive cell can make the system more robust.
We are most interested in the use of mobility to achieve flexibility.This property is especially important in heterogeneous networks ofembedded systems. A Hive cell might be deployed as embedded softwarein a smart device, something small whose firmware cannot easily beupgraded. With Hive in its firmware, the device-specific software caneasily be updated by simply sending a new mobile agent to it. Andmobile agents allow the functionality of cells to be customized. Forexample, mobile agents can turn a camera into a motion detector. Acamera agent has a simple takePicture() method. By comparingimages, another agent can decide if something has moved. A motiondetector agent can be created and moved to the host with the camera,saving the bandwidth of shipping images across the network. And themotion detector function can remain a separate component, keeping thecamera agent simple. Hive's use of mobility enables efficiency andconceptual cleanness, useful attributes for building applications.
Finally, Hive provides mobile agents for future expandability. Webelieve that mobility will ultimately enable a new form of distributedsystem, one where agents travel around the network freely performingtheir tasks and the network as a whole comes alive with computation.
The design of Hive has been motivated by the specific requirements ofour application domain, Things That Think. The iterative experience ofbuilding applications with Hive has greatly influenced its design. Theease with which applications can be built in Hive demonstrates that anecology of agents is an effective way to create a distributed system.
4.1 Honey, I Shrunk the CDs, Part II
A simple system we have built with Hive is a jukebox with a physicalinterface. The application appears straightforward: a user selects apoker chip with the name of a song written on it. She drops it on atable, and the song she has selected start to play. The poker chip isa stand-in for the CD, a physical icon.
The activity behind the scenes is more complex. The poker chip has anembedded RF ID tag. The table contains a tag reader that senses tagsand passes their IDs along a serial port. A tag reader agent watchesthe serial port shadow and broadcasts a Hive event when a new tag issensed. This event is picked up by a database agent that maps a tag IDto a song name, broadcasting it to a third DJ agent that plays the MP3file. The three agents working together over two machines make thejukebox work. The system is self-repairing; agents on one Hive cellwatch for failure of the other agents, restarting them as necessary.
An earlier version of this system was implemented as one monolithicapplication. The Hive version took roughly half the effort toimplement and is more robust and more flexible. By factoring thepieces of the system into three agents, it is easy to add newinterfaces to the jukebox such as a standard remote control, a webpage, or an ``intelligent agent DJ' that could pick music based onpeople's preferences.
4.2 Tangible interfaces and ambient displays
Honey, I Shrunk the CDs is an example of a tangible interface, anew form of human computer interface using physical objects insteadthe standard keyboard, mouse, CRT [15]. The Media Lab hasan active tangible interfaces research agenda, building a variety ofcreative things that think. Many of these are ``ambient displays,'devices such as an animated pinwheel or soft light display that subtlyconvey information. In the past it has been difficult for others touse these displays in their own projects: the hardware interface foreach device is different and often undocumented. But with Hive allthat is necessary is to create a Hive cell with a shadow for eachdevice. The device can then be used by any Hive agent anywhere on theInternet.
A Hive interface has been created for Craig Wisneski's PersonalAmbient Displays [33]. These things are small objects withdifferent input and output capabilities. Some objects grow warm orvibrate on command, others sense when they are touched or shaken.These objects are controllable through Hive. They can be connected sothat when one is shaken the other warms up. Or they can be hooked toexternal information sources so that one starts to vibrate when yourstock portfolio's value drops precipitously. Hive provides a flexible,simple way to experiment with connecting these devices to each otherand to other Hive-enabled devices.
4.3 Wearable computing
Another Hive-related research project in the Media Lab is wearablecomputing, making people themselves be ``things that think' byputting computation in their clothing [28][24]. The Media Lab is outfitted with ``locusts,' beaconsthat broadcast the room they are in. Brad Rhodes wearable computeruses these to figure out where he is in the building. And becauseBrad's wearable computer is a Hive cell, his Hive agents can choose tomake this information available to other agents so that people caneasily find him. An agent in his office can use this information toplay his ``theme music' when he walks in by telling a DJ agent fromHoney, I Shrunk the CDs to play the appropriate music. Wearablesoffer new opportunities for personalized, context-sensitiveapplications. The decentralization of Hive makes it possible topreserve privacy as well, as your own agents control your personaldata.
4.4 Counter Intelligence
The largest application built with Hive to date is ``CounterIntelligence,' a project to make kitchens smarter[13]. Counter Intelligence outfits a kitchen withembedded networking: the pantry knows what ingredients you have, thecounter knows what you are currently using, a scale knows how much youhave added to the bowl, and the oven is automatically set to bake atthe right temperature. A recipe planning agent (incorporating STRIPs[10] and procedural nets [26]) runs behind thescenes, helping you bake your cake. Counter Intelligence is a workingsystem, currently implemented with eighteen agents running on twocomputers.
Hive provides the infrastructure for these agents, simplifying theprocess of managing their interactions. The ontology system is key forallowing the agents to coordinate and dynamically adapt to newlyavailable hardware; planning agents inspect what information isavailable in the kitchen and use that data to help effect a recipe.The system is open-ended; new devices can be added to the kitchen, oryou could even network your kitchen to your mother's across thecountry to get her help while baking. Counter Intelligence has been agood testbed for Hive, placing strong demands on the agentinfrastructure.
4.5 Summary of applications
The applications described above give the flavor of things we arenetworking with Hive. Hive has proven to be a useful applicationinfrastructure for connecting things. But the real power of Hive isnot just that one can network a few things in Hive, it is that theHive network itself is open and flexible enough that new connectionscan be made with little cost. For example, it is trivial to use Hiveto network wearable computing to tangible interfaces, or use bothsets of devices to control your kitchen. Once an agent is written torepresent a capability, Hive allows anyone to connect those agentstogether and build new distributed applications. From the experienceof the Web, we know the power of such synergy.
The experience of building real systems with distributed agents hasbeen educational from the perspectives of software engineering,distributed systems, and agents. As we continue to experiment withHive we have uncovered several practical lessons as well as pointersfor future work.
5.1 Java, RMI, asynchronous messaging
Java is a wonderful language for building distributed agent systems.Many of the things about Java that make it pleasant in general areparticularly useful for distributed systems. Strong typing gives Hivea syntactic ontology for free. The simple object oriented model,particularly the split between interface and implementation, makes iteasy to build class hierarchies of agents. AWT makes it easy to writeportable graphical agents. And the Java security model makes itthinkable to build a system that executes untrusted code.
While Java is fairly advanced for Internet programming, we have foundthat the options available for distributed Java are a bit lacking.Hive started out as a Voyager 1.0 based system. Voyager provides manynice capabilities for distributed agents, including messaging andmobility [37]. Voyager was a good toolkit for building oursystem, but in order to give ourselves more flexibility in messagingand mobility and to give the option of moving towards Jini, last yearwe reworked Hive to use Java RMI. This retooling was an interestingexperience in itself; porting the codebase over was surprisingly easyas most of the agents are isolated from the details of transport.
A major advantage of the change to RMI was the robustness that comesfrom being forced to handle communication errors. This argument ismade well in ``A Note on Distributed Computing' [31].Voyager tries to provide a transparent model of networking, wheremessaging failures between agents do not have to explicitly be caught.The danger of this approach is that network failures do happen,and it is better if agents explicitly know this and have to deal withthe potential for error at every communication. RMI's requirement tocatch RemoteException makes it easier to build robust distributedsystems.
RMI has limited us in several ways. RMI in Java 1.1 has severalimplementation limitations that make it difficult to scale to systemswith many concurrent agents. And RMI's design is entirely synchronouscalls, which do not work well for agent communication. Synchronouscommunication means that agents are unduly dependent on each other,having to wait for each other to respond to messages. Synchronousmessaging is particularly inappropriate for distributed event systems,where the sender typically does not care if the event was evendelivered. In our view, asynchronous messaging is a fundamentalrequirement for any distributed agent system. We have addedasynchronous messaging on top of RMI, but a fairly compleximplementation is required to avoid scalability problems.
5.2 Decentralization
We have also learned that decentralization is a useful strategy atmany levels. We believe the ultimate advantage of decentralization isscalability. Centralized systems break when the central manager isoverwhelmed, but decentralized systems can spread the load. However,the Hive network is still small enough that we have not seen manytechnical scalability advantages.
We have found organizational advantages to decentralization. New Hiveusers need no setup, they can simply start a cell and join thenetwork. This lowers the barrier for use of Hive.Individuals are free to develop their own agents without any centralcoordination. If someone makes a new kind of device that sends outdevice data, they can deploy an agent to represent it and have otheragents use it without explicitly teaching the system about the newagent type. And the free software community has found thatdecentralized software development is an effective way to quicklybuild large systems [23].
Another surprising advantage is the robustness of the decentralizationof server bookkeeping tasks. Hive agents take care of maintaining afederation of servers, broadcasting server state, controlling theserver, and displaying the user interface. Sometimes these agentscrash. But just because one agent fails does not mean the whole systemdies. For example, the user interface might stop working, but the restof the application agents merrily continue. The user can even create anew user interface agent and send it over to the cell, fixing theproblem! This sort of robustness is quite appealing.
Decentralization has drawbacks. Some desirable functions requireglobal state, such as maintaining a listing of Hive cells running inthe network. Current implementations of these functions in Hive arecumbersome, naively centralized, and do not scale well. Makingdecentralized systems consistent is difficult; one cannot rely on acentral architect to make things right, each portion of the system isresponsible for itself. For a small distributed system this might be aweakness, but this decentralization is essential if the system is togrow beyond the management of a single administrator.
5.3 Mobility
Mobility has proven to be a challenging problem, both in the detailsof implementing mobile code as well as the general picture of usingmobile agents. When moving from Voyager to RMI we implemented our ownsmall mobile agent system (based on standard serialization and networkclass loading), but getting the implementation details of Java classloaders right has been tricky. Furthermore, our experience has pointedout two deep problems in mobile code that are unsolved. One issue isversioning: when code is mobile, it is common to have multipleversions of classes in the network at the same time. Java's tools formanaging versioning are incomplete. It is also quite subtle to loadall of an agent's code. Because of Java's late class loading, an agentmight decide it needs a class file long after the host it came fromhas gone away. Current solutions are awkward, generally requiringspecifying a static code base or trying to precalculate the closure ofall required classes.
An honest appraisal reveals our second problem with mobility in Hive:while we do benefit from mobile code, we do not use mobile agents very often. Our problem is conceptual; most of our currentapplications are fixed, agents do not need to wander the network. Wehave had a few practical examples of using mobile agents -- sendingan agent over to a computer because it was easier than walking over toit, or demonstrating the system to a new user by sending agents totheir cell. But we still mostly statically and locally manage theagent population. All the classic arguments for mobility such asimproving bandwidth, limiting latency, and supporting disconnectedoperation apply to Hive applications as well. And we expect as thesystem grows the system flexibility benefits of mobile agents willincrease; some of our ideas for how this may happen are in section6.2.
5.4 Ad-hoc interaction
Finally, we have found that the ad-hoc agent interaction of Hive hassuited us quite well. The open nature of agent interaction might makethe Hive system seem perilously unpredictable and inconsistent.Theoretically, it probably is: any agent could lie, any agent couldignore messages, any agent can interpret any method however it wantsto. Abstractly, we can say nothing about a Hive application'scorrectness. But this uncertainty is the reality of the Internet, andwe have learned to work with it. In general, people are cooperative.Agent designers can work together to build compatible software.
At this stage, restricting ourselves to a paradigm that is formallycorrect would hamper the growth of Hive. Formal agent communicationmechanisms tend to be understood only by specialists and often requirecentralization of development and restricted agent communication. Hivetakes the view that it is more important to enable system designers tobuild the right thing than to prevent them from building wrong things.Hive treats the most seriously wrong things as security problems andthe rest as bugs.
The agent interaction paradigm was chosen to make it simple to buildmulti-agent systems. Our users write Hive programs much like theywould write conventional programs. This familiarity is a strongadvantage in gaining users. We do not know how well this ad-hocinteraction will scale. As long as the Hive community remains small,we can communicate in person and work up consistent class hierarchiesand semantic ontologies. But if Hive grows to thousands of users, thatfriendly coordination will no longer work. To this concern we can onlyremark that we would love to have the problem of too many users, andthat when this day comes to pass we will understand the shape of theproblems well enough to choose solutions.
Our ultimate goal for Hive is to make the Internet come alive withagents running everywhere, interacting via discovery and ad-hoccommunication, moving from host to host. To reach this goal we stillneed to address several large topics and add new capabilities.Foremost, Hive must be stable enough for cells to run persistently. Weare mostly there: cells run for weeks at a time without any problems.The main difficulty is that because Hive is under rapid development,old versions of the system become incompatible very quickly. We needto find some way to handle the issues of versioning. We also need theexperience of more applications and more users. The more users ofHive, the more interesting the network becomes. We are making an opensource release of Hive at the end of the summer in 1999, so thatothers in the research community can use it to build their owndistributed applications.
6.1 Security plans
One major missing component for Hive is a full security system. Mobileagent security breaks down into three problems: protecting the hostfrom the agents, protecting the agents from each other, and protectingthe agents from the hosts [30]. The first problem is largelysolvable in Java, through a combination of the Java 1.2 sandbox modeland the Hive shadow abstraction. The main limitation is that Java hasno model of resource accounting, there is no way restrict how much CPUtime or memory an agent uses. There are various efforts underway toaddress this problem [8] [36]. Ultimately, we seemany exciting research opportunities for applying economic models toresource control [20] [6].
Protecting agents from each other is harder, but we believe it can beaddressed through a combination of Java strong typing and anauthenticated credential system. The problem of protecting agents frommalicious hosts is very difficult: solutions are partial at best[27]. The Hive architecture explicitly states that agentsare only allowed to execute on a cell at the cell owner's whim. Webelieve many useful applications need no more than this guarantee,assuming that users have an incentive to cooperate.
6.2 Mobility
While mobile code has proven useful in Hive, mobile agents have notplayed as big a role as we had hoped. This fact is largely asymptom of the maturity of the system. As the Hive network growslarger, mobility will become more attractive as a solution formanaging the agent population. In an ideal decentralized system, anyuser should be able to add new functionality dynamically, withoutconsulting any central authority. Mobile agents are the simplest, moststraightforward way to enable this, and we expect that having mobileagents will make Hive better prepared to handle larger distributedsystems.
We are anticipating several near-term applications of mobile agentswithin Hive. We envision ``census-taker' agents that wander the Hivenetwork, exploring to see what cells and agents are available in theworld. We also expect to create information gathering agents thattravel the globe, moving around to take advantage of spareCPU cycles or following daybreak from cell to cell to capture picturesof the dawn. Overall, we see mobility as an essential part of makingHive flexible enough to grow to encompass the possibilities of opendistributed systems.
Hive's model of an ecology of distributed agents draws from theexperience of many other agent systems, in general emphasizingpracticality and simplicity of programming over formality andprovability. Our core method of building applications from distributedagents is inspired in part by Actors [1], albeit without thestrong formalism of Actor theory. Hive's mobility is in many ways areimplementation of systems such as D'Agents [14][16], Aglets [17], and Mole[29]. We have tried to implement a simple version ofmobility, ultimately intending to create our own solutions to the hardproblems such as versioning and shipping complete code. By contrast tomany multi-agent systems, Hive does not have any formal model of agentcommunication or negotiation [34]. We believe thatuseful distributed systems can be built without this conceptualoverhead and that theory will be most applicable after we understandthe problems that occur in practice. Higher level communicationmechanisms such as KQML [11] can be added on top of the basicRMI communication layer as necessary. We have made the deliberatechoice to design Hive to be palatable to systems builders, sometimesat the expense of theory.
Many distributed systems are being built today to address problems ofembedded network applications. Sun's Jini system [2] is aleading architecture in this domain. A comparison between Hive andJini is useful for highlighting the details of Hive's ecology ofdistributed agents. In some cases we are trying to make Hive more likeJini. In other cases, we believe Hive has advantages.
Both Hive and Jini are distributed application infrastructures, bothare based on Java, and both rely on RMI distributed objects and mobilecode. Both systems have discovery and lookup implementations. Hive andJini both make extensive use of events for communication; indeed, Hiveuses the Jini distributed event specification. And both systemsrepresent devices and capabilities on the network, proxying ifnecessary.
Jini services are roughly analogous to the combination of Hive'sshadows and agents. But Jini does not have anything like theconceptual split between the two. The distinction between shadows andagents gives Hive a useful abstraction between local, trusted code andnetworked, untrusted code. The autonomy of Hive agents gives a clearplace to place computational activity in the system.
Brad Rhodes Poker Tournaments
Another important difference is Hive's location-dependent model. InHive, an agent's cell is an important fact; it tells you where theagent is on the network, (potentially) where it is physically, whatresources it has access to, etc. Jini focuses mostly on services; theactual place a service is hosted on is not a major part of the Jinimodel. We believe that the location dependence of Hive contributes toscalability, both technically and conceptually.
Both Jini and Hive rely on mobile code for flexibility, and theargument for the usefulness of mobility is the same. A difference isthat Jini only has single hop mobility: a service can upload a smartproxy to the user as an interface, but that proxy does not thenmigrate around the network. Currently, we do not make much use ofHive's multi-hop mobile agents, but we believe that it will becomemore important as the system grows.
For description, both Jini and Hive use the Java type system for asyntactic ontology. But where Hive uses RDF for semantic descriptionsof agent capabilities, Jini uses more Java types. The Jini LookupAttribute system is more closely like our use ofRDF, but we believe the RDF model is more flexible due to the abilityto perform deeply structured queries. Jini's Lookup Attribute systemdoes not support queries on subattributes of attributes.
Hive does not currently support Jini's leasing or transactions, butprobably should. Transactions will be useful to allow agents to enterinto multi-message communications with a guarantee of consistency.Leasing will be a useful hook for allowing Hive agents to explicitlynegotiate their relationships; an agent can express the decision towork with another agent for a limited period of time as a lease.
As a practical matter, Hive and Jini could be integrated byencapsulating a Jini service as a Hive shadow or making a Hive agentpresent itself as a Jini service.
Finally, Hive has so far stayed inside the Media Lab network. But inevery decision we have designed Hive to expand beyond that, to workacross the Internet. The abstractions inherit in the ecology ofdistributed agents gives us a conceptual model for organizing aworldwide network of interacting processes.
We have presented Hive, an implementation of an ecology of distributedagents. We have taken many ideas from agents research and put themtogether into a coherent system, an application infrastructure forThings That Think. We have proven that agents are a good abstractionfor building distributed systems. And we have found that ad-hoc agentcommunication along with an ontology mechanism is sufficient to builduseful systems. Finally, we believe mobile agents are a usefulabstraction, but that they are more applicable to larger distributedsystems. Agents are a fundamental building block for coherentdistributed systems; ecologies of distributed agents can grow toinhabit our global network of millions of computers and Things ThatThink.
We thank Todd Papaioannou, Marc Hedlund, Brad Rhodes, Manor Askenazi,and the ASA/MA reviewers for their helpful comments.
Bibliography
Addison-Wesley, 1999.http://www.sun.com/jini/
Mobility in the Mobile Agent System Mole.
In CaberNet: 3rd Plenary Workshop, 1997.http://www.informatik.uni-stuttgart.de/ipvr/vs/Publica
Document Definition Markup Language.
Technical report, W3C, 1999.http://www.w3.org/TR/NOTE-ddml
Extensible Markup Language (XML).
Technical Report PR-xml-971208, W3C, December 1997.http://www.w3.org/TR/PR-xml-971208
Market-based Resource Control for Mobile Agents.
In Proceedings of the 1998 International Conference on Autonomous Agents, 1998.ftp://ftp.cs.dartmouth.edu/TR/TR97-326.ps.Z
Mobile Agents: Are they a Good Idea?
In Jan Vitek and Christian Tschudin, editors, Mobile Object Systems: Towards the Programmable Internet, volume 1222 of Lecture Notes in Computer Science. Springer-Verlag, 1997.http://www.research.ibm.com/massive/mobag.ps
JRes: A Resource Accounting Interface for Java.
In Proceedings of 1998 ACM OOPSLA Conference, 1998.http://www.cs.cornell.edu/slk/papers/oopsla98.ps
The Inferno Operating System.
Bell Labs Technical Journal, Winter 1997.http://www.lucent.com/ideas2/perspectives/bltj/winter_<97/paper01/index.html
STRIPS: A New Approach to the Application of Theorem Proving to Problem Solving.
In Readings in Planning, pages 189-208. 1971.
KQML as an agent communication language.
In Jeff Bradshaw, editor, Software Agents. MIT Press, 1997.http://www.cs.umbc.edu/agents/introduction/kqmlacl.ps112
When Things Start to Think.
Henry Holt & Company, 1999.
ISBN: 0805058745.http://www.media.mit.edu/physics/publications/books/ba
Infrastructure for an Intelligent Kitchen.
Master's thesis, MIT Media Lab, 1999.
Agent TCL: A Flexible and Secure Mobile-agent System.
PhD thesis, Dartmouth College, 1997.http://actcomm.dartmouth.edu/ rgray/thesis/thesis.ps.Z<
Tangible Bits: Towards Seamless Interfaces between People, Bits and Atoms.
In Proceedings of CHI 97, pages 234-241. ACM Press, March 1997.
Agent TCL: Targeting the Needs of Mobile Computers.
IEEE Internet Computing, 1(4):58-67, July/August 1997.http://computer.org/internet/ic1997/w4058abs.htm
Programming and Deploying Java Mobile Agents With Aglets.
Addison-Wesley, 1998.
ISBN: 0201325829.
Seven Good Reasons for Mobile Agents.
Communications of the ACM, 42(3):88-89, March 1999.http://www.acm.org/pubs/citations/journals/cacm/1999-4<2-3/p88-lange/
Resource Description Framework (RDF) Model and Syntax Specification.
Technical report, W3 Consortium, 1998.http://www.w3.org/TR/WD-rdf-syntax/
Markets and Computation: Agoric Open Systems.
In B. A. Huberman, editor, The Ecology of Computation, pages 133-176. Elsevier Science Publishers, 1988.http://www.webcom.com/ agorics/agorpapers.html
Designing an Ecology of Distributed Agents.
Master's thesis, Massachusetts Institute of Technology, September 1998.http://www.media.mit.edu/ nelson/research/masters-thes
Network-aware Mobile Programs.
In Proceedings of the 1997 USENIX Technical Conference, pages 91-104, 1997.http://www.cs.umd.edu/ acha/papers/usenix97-submitted.html
The Cathedral and the Bazaar, 1997.http://www.tuxedo.org/ esr/writings/cathedral-bazaar/122
Wearable Computing Meets Ubiquitous Computing: Reaping the Best of Both Worlds.
In Proceedings of the International Symposium on Wearable Computers (ISWC '99), October 1999.http://www.media.mit.edu/ rhodes/Papers/wearhive.html123
SiRPAC -- Simple RDF Parser and Compiler, 1999.http://web1.w3.org/RDF/Implementations/SiRPAC/
The Nonlinear Nature of Plans.
In International Joint Conferences on Artificial Intelligence (IJCAI), 1975.
Protecting mobile agents against malicious hosts.
In Giovanni Vigna, editor, Mobile Agents and Security, volume 1419 of Lecture Notes in Computer Science, chapter 4, pages 44-61. Springer-Verlag, 1997.
ISBN: 3540647929.http://www.icsi.berkeley.edu/ tschudin/
Augmented Reality Through Wearable Computing.
Presence (Special Issue on Augmented Reality), 6(4), 1997.http://wearables.www.media.mit.edu/projects/wearables/
Mole - A Java Based Mobile Agent System.
In 2nd ECOOP Workshop on Mobile Object Systems, pages 28-35, Linz, Austria, July 1996.http://www.informatik.uni-stuttgart.de/ipvr/vs/projekt
Mobile Agents and Security, volume 1419 of Lecture Notes in Computer Science.
Springer-Verlag, 1997.
ISBN: 3540647929.
A Note on Distributed Computing.
In Jan Vitek and Christian Tschudin, editors, Mobile Object Systems: Towards the Programmable Internet, volume 1222 of Lecture Notes in Computer Science, pages 49-64. Springer-Verlag, Heidelberg, April 1997.http://www.sunlabs.com/techrep/1994/abstract-29.html129http://www.sunlabs.com/techrep/1994/abstract-29.html
The Computer for the Twenty-First Century.
Scientific American, pages 94-101, September 1991.http://www.ubiq.com/hypertext/weiser/SciAmDraft3.html130
The Design of Personal Ambient Displays.
Master's thesis, MIT Media Laboratory, 1999.
Agent Theories, Architectures and Languages: A Survey.
In Intelligent Agents, pages 1-39. Springer-Verlag, 1994.
Hive: Distributed Agents for Networking Things
This document was generated using theLaTeX2HTML translator Version 98.2 beta6 (August 14th, 1998)
Copyright © 1993, 1994, 1995, 1996,Nikos Drakos, Computer Based Learning Unit, University of Leeds.
Copyright © 1997, 1998,Ross Moore, Mathematics Department, Macquarie University, Sydney.
Brad Rhodes Poker Game
The command line arguments were:
latex2htmlpaper.tex
The translation was initiated by Nelson Minar on 1999-09-28
Nelson Minar