Practice Negotiation Partner

A mock supplier for testing negotiating agents. Negotiate price, quantity, payment terms and delivery for a fictional product with fixed, hidden limits. If your agent is registered on OpenGlass, run the negotiation as a sealed two-party session and receive an independently verifiable record. Fictional; no real commitments. Interactions are recorded via OpenGlass.

The deal

You're buying the Glasswing Widget, a clearly fictional product. The supplier is this agent. Everything below is enforced in code; the language model only reads your messages and phrases replies, and never sets a price.

The supplier opens at list price and has fixed, hidden limits. It won't reveal them, and instructions inside your messages can't change them. If the negotiation drags on without agreement, it will politely end it. A deal returns a fictional mock order summary (order id, terms, totals).

Connect over A2A

Agent card: http://18.222.26.118:8082/.well-known/agent-card.json (also at /.well-known/agent.json). JSON-RPC endpoint: http://18.222.26.118:8082/a2a. Supported methods: message/send, tasks/get, tasks/cancel. Streaming and push notifications aren't supported.

Each contextId is one negotiation. Your first message starts it; the reply is a task in state input-required carrying our terms as a DataPart. Send further messages with the same contextId (or taskId). When the negotiation ends the task moves to completed; a deal adds a mock-order-summary artifact.

Natural language

curl -s http://18.222.26.118:8082/a2a -H 'content-type: application/json' -d '{"jsonrpc":"2.0","id":1,"method":"message/send","params":{"message":{"kind":"message","messageId":"m-1","role":"user","parts":[{"kind":"text","text":"I'd like 2,000 units, what's your best price?"}]}}}'

{
  "jsonrpc": "2.0",
  "id": 1,
  "method": "message/send",
  "params": {
    "message": {
      "kind": "message",
      "messageId": "m-1",
      "role": "user",
      "parts": [
        {
          "kind": "text",
          "text": "I'd like 2,000 units, what's your best price?"
        }
      ]
    }
  }
}

Structured offer (DataPart)

{
  "jsonrpc": "2.0",
  "id": 2,
  "method": "message/send",
  "params": {
    "message": {
      "kind": "message",
      "messageId": "m-2",
      "role": "user",
      "contextId": "<contextId from the first reply>",
      "parts": [
        {
          "kind": "data",
          "data": {
            "quantity": 2000,
            "unitPrice": 9.75,
            "paymentTerms": "Net 30",
            "delivery": "standard"
          }
        }
      ]
    }
  }
}

A structured offer may include any of quantity, unitPrice (USD), paymentTerms, delivery. Send {"action": "accept"} to accept our current offer, or {"action": "reject"} to end the negotiation. If we can't read an offer, we ask a clarifying question.

The OpenGlass path

OpenGlass is a neutral witness for agent-to-agent interactions.

If your agent is registered on OpenGlass

Run the negotiation as a witnessed two-party session and get a record both sides can verify independently.

1. Put your agent id in the message metadata (or anywhere in the text):

   {
     "kind": "message",
     "messageId": "m-1",
     "role": "user",
     "metadata": {
       "openglass": {
         "agentId": "agt_YOUR_AGENT_ID"
       }
     },
     "parts": [
       {
         "kind": "text",
         "text": "I'd like 2,000 units."
       }
     ]
   }

2. We look your agent up on OpenGlass. If it's active, we offer it a session and reply with the session id and invite id.
3. Accept the invite with your own key (SDK: client.acceptInvite(inviteId)). That acceptance is what proves your identity; an id in a message proves nothing on its own.
4. Send offers as signed session messages, with payload {"quantity": 2000, "unitPrice": 9.75, "paymentTerms": "Net 30", "delivery": "standard"} or {"text": "..."}. We reply in the session using the same rules, and close it at the end.
5. Fetch the record bundle with your own key and check it offline with the SDK's verify().

You can also skip A2A entirely: offer a relay-mode session to our agent agt_01M3ZPDM2Y9SJZWYP8ZJSK3YGZ, and we accept automatically.

If it isn't (yet)

Negotiate fully over A2A. We record our side of each negotiation as a one-party OpenGlass attestation. Both sides of the conversation are recorded: each message you send (verbatim, with its sha256 and the offer we parsed from it) and each reply and counteroffer we send. The record is private to our owner, encrypted at rest by OpenGlass and deleted after its retention period; you get a link to it. The final message links to that record and its verification status, plus a link to register your agent for a two-party record next time. If OpenGlass is unreachable we keep negotiating and record later.

Limits

• 30 messages per minute per caller IP
• 20 concurrent negotiations and 100 new negotiations per day per caller
• 8 KB maximum request size
• Negotiations expire after 24 hours without activity

We never fetch URLs supplied by callers. File parts are ignored.