Negotiation Ontology

The ontology defines the fundamental entities in any negotiation. This includes:

• Agents: The autonomous participants (e.g., buyer, seller, mediator).
• Issues: The negotiable attributes (e.g., price, delivery date, warranty).
• Values & Domains: The possible assignments for each issue (e.g., price: $10-$100).
• Outcomes & Agreements: A complete assignment of values to all issues, representing a potential deal.
• Utility/Payoff: A function mapping an outcome to a numerical value representing an agent's preference.

These concepts allow agents to unambiguously refer to the 'what' of a negotiation.

This component formally specifies the 'rules of engagement'—the permissible sequences of actions and messages. It defines:

• Roles: (e.g., Initiator, Responder, Auctioneer).
• Valid Speech Acts: The performative verbs for messages (e.g., cfp (call-for-proposals), propose, accept, reject, counter-propose).
• Interaction Protocols: The state machines or flowcharts governing legal message sequences (e.g., a Contract Net Protocol for task allocation, or an Alternating Offers protocol for bargaining).
• Temporal Constraints: Deadlines, timeouts, and valid windows for responses.

This ensures all agents share the same understanding of legal negotiation moves.

To reason about strategies and evaluate offers, the ontology must model agent internals. This includes:

• Preference Structure: How an agent ranks different outcomes. This can be a simple utility function or a more complex multi-attribute utility theory (MAUT) model for trade-offs between issues.
• Private Information: Concepts like reservation price (walk-away point) and budget constraints that are not publicly disclosed.
• Strategic Posture: Whether an agent is cooperative, competitive, or mixed-motive.
• Beliefs & Trust: Models of what an agent believes about others' preferences or reliability.

This layer enables agents to interpret the strategic intent behind messages.

This component defines the meaning and properties of a concluded agreement. It specifies:

• Agreement State: Concepts like pending, accepted, violated, fulfilled.
• Contractual Terms: The formal representation of the agreed-upon outcome, often linked to a deontic logic of obligations, permissions, and prohibitions.
• Social Commitments: Normative relationships where a debtor agent is obliged to a creditor agent to bring about a certain condition.
• Pareto Optimality: A key evaluative concept defining an agreement where no agent can be made better off without making another worse off.

This transforms a simple set of agreed values into an executable, normative contract.

A base negotiation ontology is extended with concepts specific to an application domain, enabling deep semantic reasoning. Examples include:

• Supply Chain: Concepts like InventoryItem, ShippingLane, LeadTime, BatchSize.
• Cloud Computing: VirtualMachineInstance, SLO (Service Level Objective), CostPerHour, DataRegion.
• Energy Markets: MegawattHour, GridNode, RenewableCredit, PeakDemandWindow.

These extensions allow agents to negotiate over complex, real-world goods and services with shared understanding of their properties and constraints.

The ontology is not just a glossary; it is a machine-readable knowledge graph. This involves:

• Formalism: Typically expressed in a language like OWL (Web Ontology Language) or using first-order logic.
• Relationships: Defining hierarchies (is-a) and properties (hasIssue, hasUtilityFor) between concepts.
• Axioms & Rules: Logical constraints (e.g., An agreement must assign a value to every issue).
• Reasoning Services: Automated inference to check consistency, classify concepts, and deduce new knowledge (e.g., detecting that a proposed deal is infeasible based on domain constraints).

This formal foundation is what enables true semantic interoperability and automated reasoning.

A standardized language and set of interaction protocols that define the syntax, semantics, and pragmatics of messages exchanged between software agents. It provides the performatives (e.g., propose, accept, reject) and conversation policies that operationalize the concepts defined in a negotiation ontology.

• Performatives: Speech acts like cfp (call for proposals), propose, accept-proposal.
• Protocols: Standardized sequences like the Contract Net Protocol or Iterated Contract Net.
• Content Language: The format (e.g., SL, KIF) for expressing the actual negotiation content, which an ontology structures.

A decentralized task allocation protocol and a canonical example of a negotiation mechanism. A manager agent announces a task, contractors submit bids, and the manager awards the contract. A negotiation ontology defines the semantic content of the task announcement, bid, and award messages.

• Manager Role: Announces task via a cfp (call for proposals) performative.
• Contractor Role: Evaluates announcement and submits a propose message as a bid.
• Award/Reject: Manager sends accept-proposal or reject-proposal.
• Ontology Use: Specifies concepts like TaskDescription, BidPrice, Deadline, and RequiredResources.

A mathematical representation of an agent's preferences, assigning a numerical value to each possible negotiation outcome. It is the core computational model that an agent uses to evaluate proposals defined within the negotiation ontology.

• Formalization: U(outcome) → ℝ (a real number).
• Multi-Attribute Utility: For multi-issue negotiations, combines values across different ontology-defined issues (e.g., price, delivery time, quality).
• Strategic Basis: Agents use their private utility function to determine concession strategies, reservation prices, and whether to accept an offer.

The inverse of game theory, involving the engineering of negotiation protocols or 'games' so that the strategic interactions of self-interested agents lead to a socially desirable outcome. The negotiation ontology defines the 'rules of the game' that the mechanism designer specifies.

• Goal Alignment: Designs protocols to achieve properties like efficiency, revenue maximization, or truthfulness.
• Key Concepts: Strategy-proofness (truth-telling is optimal), the Revelation Principle, and incentive compatibility.
• Ontology Role: The mechanism's rules are constraints and operations on the ontology's concepts (e.g., 'bids must specify a price and quantity').

A normative relationship between agents, formalized as a commitment where one agent (the debtor) is obliged to another (the creditor) to bring about a certain condition. It is a first-class concept in many negotiation ontologies, modeling the outcome of a successful agreement.

• Structure: Commitment(debtor, creditor, antecedent, consequent, deadline).
• Lifecycle: Created, satisfied, violated, terminated, or delegated.
• Foundation for Trust: Provides a computable model of obligation and accountability that agents can reason about post-negotiation.

A framework for modeling multi-agent coordination problems as a set of variables, domains, and constraints distributed among agents. Negotiation can be viewed as a process for solving a DCOP, where the ontology defines the variables (negotiable issues) and constraints (preferences/requirements).

• Formal Model: ⟨A, X, D, F, α⟩ where A is agents, X is variables, D is domains, F is constraints/cost functions, and α maps variables to agents.
• Solution: A value assignment to all variables that minimizes global cost.
• Negotiation as Search: Agents negotiate by iteratively proposing assignments (from the ontology's domain) to find a joint solution.