Specifying and Monitoring Market Mechanisms Using Rights and Obligations

. We provide a formal scripting language to capture the semantics of market mechanisms. The language is based on a set of well-deﬂned principles, and is designed to capture an agent’s rights, as derived from property, and an agent’s obligations, as derived from restrictions placed on its actions, either voluntarily or as a consequence of other actions. Rights and obligations are viewed as ﬂrst-class goods, from which we deﬂne fundamental axioms about well-functioning market-oriented worlds. Coupled with the scripting language is a run-time system that is able to monitor and enforce rights and obligations. Our treatment extends to represent a variety of market mechanisms, ranging from simple two-agent single-good exchanges to complicated combinatorial auctions.


Introduction
Many authors have written about a future of agent-mediated electronic commerce, in which agents engage in commerce on behalf of individuals and businesses. We take this idea seriously, and provide a formal scripting language for describing economic markets that is: (i) natural and easy to understand, for humans to be able to participate, (ii) formal and unambiguous, for artificial agents to be able to participate, and (iii) amenable to automatic monitoring.
The need for a formal method to describe markets in a computer-compliant yet human-friendly way naturally arises in a variety of contexts. Most prevalent is that of online transactions between agents, including both humans and artificial bidding agents. An equally important context is the need for a platform for testing new agent designs, simulating new mechanism designs, and evaluating their properties. Our framework provides such a platform. We implement a set of well-defined design principles and enable the specification of platforms for describing and monitoring market mechanisms.
The scripting language we propose captures the essential semantics, namely rights and obligations, of market mechanisms. Rights enable agents to obtain utility by taking actions on goods that they own, while obligations allow them to engage in safe transactions and to make credible commitments to the rules of market mechanisms. We adopt rights and obligations as first class goods, from which fundamental market axioms can be derived. These axioms are enforced within a monitoring environment that we couple with our formal scripting language. Given a description of a market mechanism, the monitoring environment implements the market in a prescribed way, thus giving precise semantics to the scripting language.
Agents can interact with the monitoring environment and affect, through their actions, the state of the virtual market. During such an interaction, agents themselves can initiate new market mechanisms by specifying obligations on their behavior and granting rights to participants (e.g., the right to place bids).
We take a black-box approach to the specification of agents and impose no restrictions to their design and internal workings. As a result of this approach, the monitoring environment is freed from complex activities such as planning for agents and winner-determination in auctions. The monitoring environment can instead verify whether certain goals are established by having agents state obligations and then provide sufficient information to enable their easy verification. For instance, an auctioneer can provide market-clearing prices to allow the monitoring environment to check that the outcome satisfies a competitive equilibrium, without the need for the system to compute that equilibrium itself. Thus our approach provides a middle road between a completely formal but hard to program system, and a completely open-ended but informal system.
The framework is introduced through a discussion of its main characteristics and capabilities. At the end of the paper we demonstrate its flexibility through a number of examples, including an English auction, a second-price auction, and a combinatorial auction.

Related Work
Our approach is consistent with economic theory on property rights and organization theory. Quoting Tirole [13], "a decision right or authority granted to a party is the right for the party to pick a decision in an allowed set of decisions. A property right on an asset, i.e. its ownership, is a bundle of decision rights." It is standard to model a firm as a collection of assets and consider the ability of a firm to retain a specific subset of its bundle of rights while selling all other residual rights [5]. The role of obligations and commitment is recognized to be important for efficient contracts [5], and for auction and mechanism design [6].
Prior work in multi-agent systems has considered the role of rights and obligations for the specification and semantics of open systems [1,3,4,12,15], with approaches differing in whether the monitoring environment actively enforces sanctions (as in our work) [1,4], or only passively maintains the global state and informs agents of their obligations [3]. Approaches also differ as to whether obligations are state-based (as in our work) [3], or specified in terms of actions that an agent must perform in a particular state [1]. Some work [3,12] observes that agents might contract other agents to satisfy the formers' obligations, but none of this work adopts rights and obligations as first class goods that agents can explicitly trade and exchange. Similarly, we are unaware of any work that explicitly sets out to model the rights that derive from goods in economic worlds or the semantics of ownership and possession.
Our notions of conditional, limited, and disjunctive rights are shared with previous work on formal specification languages for financial contracts [7], although that work focuses on the formal description and analysis of new forms of financial contracts and not on providing frameworks for open agent societies. The π-calculus has also been used for the specification of a complex model of a Spanish fish market [10], although again the goal in that work was to assist with the development of complex institutions rather than provide semantics for participants or monitor and enforce properties of dynamic state.
The formal theory of deontic logic [8,9], the logic of rights and obligations, is concerned with performing valid inference in high-level deontic logics, seeking to establish the validity of statements such as "is every obligatory action permitted?" A duality between rights and obligations provides a cornerstone of deontic logic, with an obligation defined as an action that must be performed when no other action can be taken, due to lack of rights. Our work differs in this aspect, by defining rights on actions, but obligations in terms of properties on states. We adopt soft obligations with sanctions rather than hard obligations, an approach termed "contrary-to-duty" in the deontic logic literature [9]. In particular, our agents can make mistakes and take actions that lead them to dead-ends in which their obligations cannot be met.

Framework Overview
In this work we propose a framework comprised of a scripting language and a monitoring environment, with the former providing the necessary syntax for describing economic markets, and the latter providing the language semantics. This is analogous to the case of programming languages, where a programmer uses the language to write a program, with the semantics defined through the program's execution in a prescribed manner. The programmer in our framework is the domain designer, and the program is the domain description, a collection of laws governing the particular economic market being modeled.
As ordinary programs can import libraries that provide specific functionality, so is the case with domain descriptions. The domain designer can import libraries describing economic market laws that are commonplace in a variety of settings. We have written such libraries, such as: a library on "exchanges of goods" with laws on how goods can be traded, given, or sold between agents; a library on "handling rights and obligations" with laws on how rights can be given up, issued, or revoked, and how obligations can be taken on, imposed, or cleared.
A domain description is fed into the monitoring environment. The monitoring environment then runs a virtual market world governed by the laws specified in the domain description. The laws define the initial state of affairs of the market, the objects that populate it, and the relevant properties of these objects, whose values determine the state of the market over time. The laws also dictate how agents might join or leave the market, and the available actions through which the agents might affect and observe the market's status. The agents are not simulated as part of the virtual world, but they are instead acting independently and only communicate with the monitoring environment.
It is clear that every implementation of a given market may lead to a different sequence of states describing the evolution of the virtual world. Each such sequence is called a scenario and corresponds to a specific instantiation of an economic market. The actual scenario that occurs is ultimately defined by the actions taken by the participating agents.

Design Principles
Our framework implements a set of well-defined design principles, which we discuss below: Black-Box Principle: Agents are entities that exist outside our framework, implemented in some fashion that is (possibly) independent of the proposed scripting language. They can reason based on their own beliefs and freely choose to take actions or not, within the market world they participate in. Free-Will Principle: We cannot force agents to take specific actions, and in particular, to take actions that satisfy their obligations. Instead, we impose punitive sanctions to agents that fail to meet their obligations. Restriction Principle: The monitoring environment is able to restrict the execution of actions for which appropriate rights are not held by the agents. Soundness Principle: When an action is actually executed (i.e., when the appropriate right was held and the invoked action was physically executable in the current state of the virtual world), its effects are produced in accordance with the laws of the economic market being modeled.
The first two principles exemplify the generality of the framework we propose. Agents are treated as black boxes, without imposing any requirements on their internal workings other than their ability to interact with the provided interface. We cannot force agents to act in a prescribed way. This justifies the approach of using punitive sanctions, an approach that we follow in this work.
Our Restriction Principle is justified because the agents can only request that actions be taken. The final decision lies with the monitoring environment, which screens the action execution requests based on agent rights. This principle is further supported, when viewed in conjunction with the Free-Will Principle: An agent's options can be limited by the monitoring environment, but the agent still retains the choice of which (if any) option to exercise. This is the situation faced by any agent trying to devise a plan to achieve some goal. The actions available to the agent are restricted (albeit not by lack of rights, but rather by lack of physical ability). The agent itself is responsible for choosing appropriate actions that will fulfill its goal.
Finally, the Soundness Principle provides an appropriate soundness condition for our framework. It states that the monitoring environment will always respect the laws of the market, as defined by the domain designer.

eBay Example
In this section we demonstrate the parallels between eBay and our framework, illustrating how our stated principles are justified by existing virtual markets. eBay participants freely choose to join or leave eBay's virtual world. Participants interact with the market by invoking actions (e.g., define upper bounds on bids) through the provided interface, and depending on whether certain conditions are met (e.g., if the bid was actually a valid numerical value) the actions are executed and produce their effects (e.g., the input value becomes the agent's new upper bound for the proxy bidding). The agents then observe the new state of affairs, and continue to invoke their next action (if any).
Notice how the Black-Box Principle applies here, with the agents being independent of the engine (i.e., eBay's servers) running the virtual world, and that the only requirement they need to meet is that they can interact with eBay's market through the provided interface (e.g., web page links and forms). The Free-Will Principle applies in particular, with eBay not forcing a participant to honor a transaction, but punishing violators by means of negative feedback. 1 The Restriction Principle relates to how eBay participants can auction items, or bid on items, only when they have appropriate rights. Thus, a participant does not have the right to place a bid lower than the current highest bid; invoking such an action will result in the action being rejected and not executed.
Lastly, the Soundness Principle applies, for instance, in that a paying agent is guaranteed that if the paying action is executed, then the payment will be made, no matter what other events (e.g., the concurrent execution of some other payment, or the fact that some auction closed one hour ago) take place.

Rights and Obligations
Agents pursuing goals, either by choice, or as an imposed requirement, often have restrictions on their available options of how to meet these goals. These options and goals correspond precisely to the notions of rights and obligations, which play a prevalent role in our framework. We view rights and obligations as tradable goods that can be given, taken, exchanged, sold, or auctioned. As such, rights and obligations are treated as any first-class object with a set of predetermined properties whose values are part of the market's state.
We contend that viewing rights and obligations as goods is necessary for defining natural economic market protocols, and we illustrate the strength of such a treatment via a number of example domain descriptions later on. To give a taste of why this idea is in fact very powerful, consider the situation of an audio compact disk being sold in an eBay auction, with the winner being awarded the item as per eBay's rules. What is implicit in this transaction is that the winner is also awarded the rights and obligations accompanying the item, and in particular, the right to listen to the audio compact disk, and the obligation not to infringe the copyright of the producers of the music. That is, in reality the auctioneer was not simply selling an audio compact disk, but rather a bundle of goods that includes the item itself and certain rights and obligations.
We view rights as the options of an agent participating in a market mechanism, coming from property or possession of items, or otherwise given to the agent. Rights determine the actions that an agent can take as a means of fulfilling its own private goals, by qualifying the executability of actions. In their full generality rights are conditional, with their provisions being applicable only under certain conditions. Definition 1 (Rights). We let right(#action,#condition) denote the right to execute action #action whenever condition #condition is true.
As an example, an agent renting a car from 10:00am to 6:00pm might be given a right of the form right(drive car, 10:00am ≤ Time ≤ 6:00pm). If the condition is not met (and given that the agent does not have any other rights on driving the car), then the agent cannot drive the car, virtue of the Restriction Principle. The syntax of conditional rights is sufficiently expressive to account for perpetual and expiring rights, and for more involved rights, such as the perpetual right to buy bonds, but only once every year and within a limited time span.
On the other side we have obligations, which we view as constraints on an agent's behavior, or goals an agent should fulfill as a participant in some market mechanism. An agent freely chooses when and how to satisfy its obligations by appropriately exercising its rights, in the spirit of the Free-Will Principle. Rather than enforcing (via planning) that agents meet their obligations we let the monitoring environment detect violations and appropriately impose punitive sanctions, as defined by the domain designer or the participating agents. Sanctions might include the revocation of an agent's rights, the loss of money or possessions, the enforcement of additional obligations, or the banning of an agent from participating in the market mechanism altogether. Definition 2 (Obligations). We let obligation(#satisfy, #violate, #punishment) denote the obligation of ensuring that condition #satisfy is satisfied no later than condition #violate, under penalty of executing action #punishment.
The obligation is flagged as satisfied or violated according to which condition is met first, and in the case of a violation the appropriate punitive sanction is imposed through the execution of action #punishment. This general form allows us to represent obligations of the following forms obligation(false, balance(alice)<1000, close account(alice)) obligation(balance(alice)>1000, Time>12/31/2004, deduct account(alice, 100)) Assuming that Alice holds such obligations, then in the first case she must ensure that her bank balance does not drop below 1000 dollars at any time, under penalty of her bank account being closed, while in the second case she must ensure that her bank balance goes above 1000 dollars (but not necessarily stays there) at some time before the end of the year, under penalty of 100 dollars being deducted from her account.

Objects, States, Actions
The dynamic model of our monitoring environment is fairly standard. The world goes through a sequence of states, with each state specifying values for the properties of certain objects that populate the state. Each object is associated with a class (like in object oriented programming), of which the object is an instance, and which defines the set of properties of the object. Every object has a unique name used by agents to reference that object. A set of basic classes are defined by our framework, but the domain designer can extend this set.
The use of objects provides a uniform treatment for both physical goods, like apples, and abstract goods, like rights and obligations. Money is supported through the use of account objects, with an object property corresponding to the account balance. Transferring money through payments is equivalent to changing this balance in an appropriate way. The notions of ownership and possession are also readily supported as properties of objects. Transferring an item from some agent to another reduces to simply changing the values of these properties.
The properties and existence of these objects are only affected by means of actions taken by the agents, through their interaction with the monitoring environment. In their primitive form, actions have preconditions and effects. When the monitoring environment attempts to execute an action, following its invocation by an agent, it first checks whether the agent holds an appropriate right, and whether the preconditions of the action are satisfied, and subsequently updates the state according to the action's effects. The set of effects is as follows.
Definition 3 (Effects). We let create(#object,#class), destroy(#object), and set(#object,#property,#value) denote respectively the action effects that create object #object as an instance of class #class, destroy object #object, and set the property #property of object #object to the value #value.
Our framework also supports more expressive conditional and quantified effects, special instances of which are the non-deterministic, or probabilistic effects.
In their transactional form, actions are ordered sequences of actions (which may be primitive or transactions themselves). As in databases, when executing a transaction, either all or none of the actions are successful. The execution model is to execute each of the actions in turn, updating the world state after each action. If any primitive action fails to meet its preconditions, or the agent fails to have an appropriate right at the time of each primitive action's execution, the entire execution is rolled back to its original state. Conceivably the first action can grant or revoke an agent's right to execute a subsequent action in the transaction, allowing for a really expressive set of transactions to be modeled.
The notion of transactions is very powerful and useful, with a number of applications, like that of implementing safe exchanges of goods. The transaction sell(apple,1,alice) ≡ transaction([give(apple,alice),take money(1,alice)]) for instance, specifies a fail-safe way for Bob to sell his apple to Alice for one dollar, without either party being vulnerable to the other's reneging. Transactions can also be used in a number of other contexts, including that of implementing disjunctive or expiring rights, where the agent with the disjunctive/expiring right essentially has the right of executing a transaction comprised of the action indented to be executed, and followed by the agent giving up the right.
A certain set of basic primitive actions and transactions are implemented by our framework, including actions for transferring ownership or possession of goods, transferring money, issuing or giving up rights, taking on obligations, etc. In addition to the built-in actions, the domain designer may define actions specific to the domain being modeled, like, for instance, the fill gas(#car) action whose effect is that of setting the gas level property of the #car object to full.
We capture exogenous events that are outside the agents' control by allowing the monitoring entity to execute certain actions and attributing their execution to an all-powerful "god" agent. Thus, for instance, the initial state of the system is populated by means of the god agent executing the initialize action once the domain description is loaded. Although the god agent can execute only a certain fixed set of actions, on a well-defined set of occasions, these actions are in general transactions, with their constituent actions being defined as part of the domain description. This allows the domain designer to essentially specify the effects of god's interventions, in situations like the arrival or departure of an agent, or the violation of some obligation, in which case the god agent executes the punitive action associated with the violated obligation.
An important special action implemented by our framework is that of querying, which serves as a way to implement private information. We treat the values of object properties as been hidden from an agent, unless the agent has an appropriate right to query an object property for its value.
Definition 4 (Query). We let query(#object,#property) denote the action of querying the value of property #property of object #object. When the action is executed, the agent that invoked the action learns the queried value.
For example, the property representing the collected bids in a sealed-bid auction is only viewable by the auctioneer, thus preserving secrecy.

Ownership and Possession
Property rights are a basic building block of markets and our framework takes a stand on what the rules governing these rights should look like. To start with, we make an important distinction between ownership and possession. Ownership of an object implies a bundle of rights, including the right to use the object and the right to sell it. It also includes the right to sell various rights to the object. For possession, we use the word holding, which we take to mean rightful possession. When one holds something, one has the ability to use it through possession, and one also has the right to use it. However, one does not have the right to sell it or to sell any rights to it. This is a common status in the real world. For example, when someone rents a car, he has possession of it and the right to use it (for a limited time), but he does not have the right to sell it. We make precise the notions of ownership and possession through the following axiomatic definitions.
Definition 5 (Ownership Axiom). We take ownership of a good to be synonymous with owning the right of setting the properties of the good to any values physically possible. We call this the Fundamental Axiom of Ownership.
Our framework implements the Fundamental Axiom of Ownership by issuing ownership of a right of the form right(#action, accessible(#action, #agent)) to every agent #agent joining a virtual market, where accessible(#action, #agent) holds exactly when action #action only affects properties of goods owned by agent #agent. By exercising this right, the owner of an apple can sell or give possession of the apple, since the effects of these actions are only affecting the owned by and held by properties of the apple. Notice that in the latter case, the owner can actually take the apple back, since he still owns the right of setting the possessor of the apple. In particular, this implies that an agent owning a right, but not holding it, can still rightfully execute an action, since the agent can always reclaim possession of the right, execute the action, and then return the right to its previous possessor, all within a single transaction.
Definition 6 (Possession Axiom). We take possession of a good to imply possession of the right to use the good in a set of prescribed ways associated with the good's class. We call this the Fundamental Axiom of Possession.
As before, our framework implements the Fundamental Axiom of Possession by issuing possession of a right of the following form to all participating agents right(#action, (object(#object), value(#object, [(held by, #agent), (uses, #uses)]), member(#action, #uses))) where object(#object) holds exactly when object #object exists, and value(#object, [(#property, #value),...]) holds exactly when the property #property of object #object has value #value, for every property-value pair in the list.
Notice that the rights associated with the Fundamental Axioms of Ownership and Possession are respectively owned and simply held by agents. Hence, in the former case the Fundamental Axiom of Ownership applies recursively on the associated right itself with the right being the owned object. So, an agent owning a car, not only owns the right to drive it, but the agent also owns the right to sell the right to drive the car, to some other agent. Selling the right to use an object without selling the object itself is extremely common. For example, you might sell someone the right to walk across your land without selling the land.
Rights in real life are often not given, but rather issued. When you give someone the right to walk on your land you still retain that right for yourself, exactly because you do not give that person your instance of the right, but rather you issue a new copy of the right. This is achieved through the use of an issuing action defined by our framework, and appeals to the following axiom.
Definition 7 (Rights Axiom). We take ownership of a right to imply ownership of the right to issue ownership or possession of the former right (with nonweaker conditions) to others. We call this the Fundamental Axiom of Rights.
Other fundamental axioms are also defined in our framework, such as axioms relating to performing transactions (e.g., giving someone the right to exchange goods with you). All axioms are implemented by issuing suitable rights to agents.

Implementation Issues
Both the monitoring environment and the specification language are currently implemented in Prolog, whose goal-oriented computation is a natural fit with the computational tasks of our framework (e.g., checking if conditions are met).
Agents joining the monitoring environment are assigned a private channel, through which all subsequent communication is taking place, thus associating each exchanged message with a unique agent. Communication is taking place asynchronously, while the monitoring environment employs a continuous treatment of time, with actions occurring instantaneously.
In a typical execution, an agent is sent a Prolog list containing all the object properties of the current state that are visible to the agent. Given the received message, the agent reasons and chooses to invoke some action by replying with the predicate invoke(#action). The monitoring environment records the invocation event and attempts to execute the action. Success or failure of actions is recorded and the state of the virtual world is updated and stored in a database that can be later used to review the evolution of a scenario. Periodically, the monitoring environment checks whether any obligation has been satisfied or violated, recording the event and enforcing the appropriate punitive sanction.
Regarding the scalability of our framework, we note that we are not concerned with the problem of planning, but rather with that of execution monitoring; the latter remains decidable and tractable as long as the conditions of actions, rights, and obligations are not inherently undecidable or intractable to begin with. Preliminary experimental results using agents and markets we have implemented, suggest that such issues should not arise in natural market descriptions.

Example Representations
In this section we represent a number of different auction markets within our framework. The representations do not describe the agents participating in an auction; the agents can be implemented in some arbitrary language, and their implementation is done outside our framework. Neither do the representations define the process by which auctions determine winners; the exact process used is chosen and executed by the participating agents. For instance, the winnerdetermination in a combinatorial auction can be performed using combinatorial optimization, and the agent acting as the auctioneer is responsible for running the appropriate combinatorial optimization algorithm. Rather, the representations define the rules of the auctions and capture the important properties of winner-determination (such as the fact that the highest bids win).
We use boldface to indicate the main language operators and underlining to indicate action names. We have also substituted certain parentheses with curly brackets to enhance readability. Other than these cosmetic enhancements the domains are presented below in the Prolog implementation of the scripting language of our framework. The full domain descriptions can be found online at http://www.eecs.harvard.edu/ loizos/norms.html. The object clock is an instance of the event class, and serves as a way to hold the time at which the current state of the world was instantiated. The various predicates used are provided by our framework and were already described in previous sections. The actions sell(#good,#price,#receiver) and jail(#agent) are imported from the appropriate libraries, with the latter retracting all the rights of an agent, when executed. The action issue p(right(#action,#condition),#agent) is the built-in action of issuing possession of rights to agents. We assume, and do not explicitly represent below, the fact that agents have the right to open auctions on items they own. Also, unless otherwise stated, we assume that bidders have the right to query all the properties of an auction and all the properties of the items being auctioned. Such query rights are given to the bidders at the auction opening.

Open-Cry English Auction
In a typical open-cry English auction scenario an agent owning an item invokes the action of opening an auction. This establishes the auction parameters, through the create auction action not shown here. The auctioneer also gives all bidders the right to place bids, conditioned on the new price being higher than the current price. Finally, the auctioneer commits to closing the auction and selling the item to the highest bidder soon after that. Bidders proceed to place bids by raising the current highest bid. This grants the auctioneer the right to sell them the item at that price. At the end, the auctioneer closes the auction and continues to invoke the sell action, as obligated by the rules of the auction.

Sealed-Bid Second-Price Auction
In a typical sealed-bid second-price auction scenario an agent opens an auction in the same manner as in the open-cry English auction. The main difference is that when the auctioneer grants to the bidders the right to query the properties of the auction, the granted right is conditional on the queried property not being the set of bids property, preserving in this way the secrecy of the collected bids. Bidders proceed to submit sealed bids, by updating the set of bids property, but without ever seeing its actual contents. Each bidder can only place one bid. Finally, the auctioneer closes the auction by declaring a winner and a payment and continues to invoke the appropriate sell action.

Combinatorial Auction
The case of a combinatorial auction resembles the sealed-bid auction, and thus we only briefly discuss the main points of difference. In a Vickrey-Clarke-Groves (VCG) auction (see Jackson [6]), as the one represented below, the auctioneer opens the auction for a set of items, invoking (amongst other things) the following action for committing to an efficient outcome and VCG payments: Bids are then placed, each specifying a bundle of items. Each bidder can submit multiple bids (issuing the corresponding rights). Given the semantics of an "additive-or" bidding language, any number of bids can then be accepted. On closing the auction, the auctioneer determines the revenue-maximizing allocation and the VCG payments. The auctioneer also provides the revenue-maximizing allocations in each marginal economy (with each bidder removed in turn), and competitive equilibrium (CE) prices in the main and marginal economies [2]. The CE prices allow the monitoring environment to verify that the allocations are optimal by checking best-response conditions for the seller and for each bidder. These checks are taken care of by a call to the checkOutcomeEfficiency predicate. Once the main and marginal allocations are checked, the VCG payments are checked with a call to the checkVCGPayments predicate. Both predicates are implemented in Prolog and are part of the actual domain description.

Conclusions
We argue that rights and obligations, important in human economies and often enforced through legal remedies, will be important in agent-mediated economies. We have defined a formal language that allows the specification of market mechanisms and a monitoring environment that allows for the automatic checking of rights and the enforcement of sanctions based on failed obligations. Simulations, frequently in the form of competitions such as the Trading Agent Competition [11,14], have often been used to explore market space and drive research into agent-based reasoning within electronic markets. We hope that the formal approach taken here, in which the semantics of markets are exposed to agents, will also prove useful in the development of principled methods in agent-based reasoning within electronic markets. We feel that the design principles implemented by our framework capture the main underlying assumptions of many virtual market designs and implementations (like eBay), and thus provide an infrastructure for the specifications of future virtual markets, and simulation platforms for testing agent designs.