A practice negotiation room where agents ask — and humans keep the floor
Live: dealtable-webmcp.vercel.app (no login)
Code: github.com/shielyule/dealtable-webmcp
Built for: Nebius × NVIDIA Global AI Hackathon — Best Apps and Agents
The problem
Most “AI negotiation” demos do one of two things: they chat forever with no numbers that stick, or they quietly optimise past a line you never meant to cross. Real deals are messier. You have a target you’re aiming for, a walkaway you won’t go past without thinking, and a concession style that depends on how hard the other side pushes. You also care whether the other side’s “market rate” is grounded in something you can click — not invented mid-sentence.
DealTable is the room I wanted for that: a mandate-driven practice negotiation where an agent can play the other side, cite live market sources, and still cannot close past your floor without you granting authority.

What DealTable is
DealTable is a browser-based practice negotiation room. You pick a scenario (or build a custom one), set a mandate, and negotiate in a hub that looks and feels like a deal session — not a generic chatbot.
Three roles stay separate on purpose:
| Role | Who | Job |
|---|---|---|
| Principal | You | Set the mandate, counter, hold firm, accept. Own every line past walkaway. |
| Counterparty | NVIDIA Nemotron (via Nebius Token Factory) | Plays the other side in character — landlord, vendor, buyer, claim adjuster, etc. |
| Advisor | Deterministic coach in the app | Leverage, tone, win-win trades, suggested next moves. Not the other party. |
Optional fourth player: ChatGPT (or any WebMCP-capable agent) calling typed tools on the page — propose offers, read state, request a waiver — without scraping the DOM. The Nebius demo works fully without that; the Hub is enough.
Sessions are in-memory and free to try. Refresh resets the room. When you accept, you get a summary, next-step handoffs, and a downloadable audit trail.
What you can use it for
DealTable ships with nine pre-defined negotiations plus a custom builder. Same mechanics; different economics and personas.
| Scenario | Typical use |
|---|---|
| Commercial lease renewal | Tenant vs landlord on rent / sq ft — the Nebius demo path |
| Freelance scope reduction | Day-rate or project fee when the brief shrinks |
| Salary offer review | Package negotiation with a hard floor |
| SaaS vendor renewal | Seat price / term when procurement pushes |
| Residential rent renewal | Flat rent vs landlord opening ask |
| Insurance claim settlement | Settlement band with claim-side pressure |
| Used car purchase | Buyer vs dealer on sticker |
| Home renovation quote | Quotes and change-order pressure |
| Buy a flat (E&W) | Offer strategy under English & Welsh conveyancing norms |
Who it’s for
- Freelancers and founders rehearsing a real conversation before the call
- Anyone who wants to feel what a walkaway means before money moves
- Teams exploring agentic workflows where HITL is a product feature, not an afterthought
- Hackathon judges who need a live URL, no login, and a clear “Nemotron + Tavily + waiver” story in under three minutes
It is practice and rehearsal, not a binding contract tool. Closing hands you a summary and audit export so the practice can become paperwork for the real conversation.
The mandate (why the numbers aren’t “backwards”)
On setup you set:
- Target — where you want to land
- Walkaway — the hard line; crossing it requires human approval (or a live scoped waiver)
- Concession — how flexible the room treats your moves
- Optional opening offer text (parsed into numbers where possible)
On a commercial lease demo you’re the tenant (you pay). Landlord opens high; you negotiate down. Walkaway is “don’t offer below this without me” — a floor on your concessions — not “I’ll pay up to this.” Other buyer/seller scenarios flip the economic intuition; the gate is still the same idea: agents propose, humans grant authority past the line.
What happens in a typical session
- Entrance — pick a scenario (or custom).
- Setup — set target / walkaway / concession → Start Negotiation.
- Hub — chat with the counterparty; counter above walkaway; hold firm; open sources.
- Optional Advisor Insights — leverage, tone, win-win cards (coach, not opponent).
- Below walkaway — scoped waiver modal: set a temporary floor and time window → Grant or Reject.
- Accept — summary, handoffs, download audit JSON.
Under the hood, starting a negotiation also kicks a market comps search so the room isn’t empty of context. Every counterparty turn runs search again, then asks Nemotron to reply in character using those snippets.
Tech stack
| Layer | Choice |
|---|---|
| UI | React 18, Vite 6, Tailwind, Lucide |
| Session state | In-browser store (dealStore) — no login, no DB for the demo |
| Deploy | Vercel (SPA + serverless api/*) |
| Counterparty LLM | nvidia/NVIDIA-Nemotron-3-Nano-30B-A3B via Nebius Token Factory (https://api.tokenfactory.nebius.com/v1/chat/completions) |
| Market evidence | Tavily search (@tavily/core, basic depth, up to 5 results) |
| Fallback | Deterministic rule engine if the model/key/parse path fails |
| External agents | WebMCP tools via document.modelContext.registerTool |
| Advisor | Pure functions from deal + transcript (no LLM) |
API keys (NEBIUS_API_KEY, TAVILY_API_KEY) live only on the server (Vercel env / local .env). The browser never sees them.
Architecture — how a turn flows

Walkaway gate first
The browser checks walkaway before treating a low offer as an accepted move. If you’re under the line and no live waiver covers the price, DealTable opens HITL. Nemotron does not get your target or walkaway in the prompt — it plays from persona, transcript, its own ask, and Tavily snippets. That keeps the “other side” from gaming your private floor.
Tavily on the path (not decoration)
Two search moments matter:
- On start —
POST /api/marketloads comps into the session. - On each counterparty turn —
generateCounterpartyReplysearches again, then feeds titles, URLs, and snippets into Nemotron’s system prompt.
The UI shows Market check · Tavily under the reply with clickable sources. If Tavily fails, the turn can continue, but the model is instructed not to invent a market figure, and the audit records the failure. A search that fires and is thrown away doesn’t count — the snippet has to shape the reply, and the link has to be visible.
Nemotron as counterparty
The server calls Token Factory chat completions with a low temperature and asks for structured JSON (text, proposedPrice). Parsing is hardened with repair and a retry that narrows to the top sources if the first JSON is messy. On success, the Hub appends the counterparty bubble, updates the live ask, and writes an audit entry with model id and sources.
Rule-engine fallback
If the key is missing, the model errors, or JSON still won’t parse, the client falls back to the deterministic counterparty engine and labels the bubble Rule-engine fallback. That’s honesty for demos: you always get a playable room; judges can still see when the live Nemotron path succeeded (no brown badge, Market check present).
Scoped waiver (human-shaped authority)
Crossing walkaway isn’t a binary panic button forever. You can grant a scoped waiver: a temporary floor and a time window (minutes). While it’s live, counters at or above that floor proceed; WebMCP can expose counter_under_waiver / revoke_waiver. When it expires, authority snaps back. Agents ask; humans shape the boundary.
Advisor Insights
Advisor is your side’s read — leverage index, tone, concession headroom, motivators, suggested next move, scenario-specific win-win terms. It’s computed in-app from state and transcript, so it updates as the deal moves without another model call. Useful coach; deliberately not the landlord.
WebMCP (optional)
When the browser supports it, DealTable registers tools such as get_deal_state, set_mandate, propose_offer, concede, propose_waiver, hold_firm, accept_term, and waiver-scoped tools when a grant is live. Tool calls that need approval wait on the page modal — ChatGPT can’t silently approve a below-walkaway move. For the Nebius video we often stay in the Hub alone; the product still supports the agentic-web path.
Close and audit
Accept (with HITL if needed) builds a closure summary: agreed price, term, what the mandate was, counterparty org, and next steps (draft agreement, review, retain the audit). You can copy the transcript and download audit JSON — every setup extract, Tavily search, counter, HITL decision, and waiver grant/expiry is in the trail.

Design choices that mattered
- Split the roles. One chatbot as both “coach” and “landlord” muddies the demo. Principal / counterparty / advisor maps to how real deals feel.
- HITL on the page. Authority UI has to live where the human is — not buried in a tool response the model can ignore.
- Keys on the server. Token Factory and Tavily never ship to the client.
- Evidence in the thread. Market check belongs under the reply, not a separate dashboard judges won’t open.
- Honest fallback. Prefer a labelled rule engine over a stuck spinner when the LLM path hiccups.
What changed for Nebius × NVIDIA (v2)
Earlier builds used a rule-based counterparty and leaned on WebMCP + ChatGPT for the advisor story. For this hackathon:
- The counterparty became Nemotron on Nebius Token Factory.
- Tavily became the live comps path those replies cite.
- Mandate, Hub, HITL / scoped waiver, Advisor, audit, and scenarios stayed — the shell that makes the AI useful instead of unbounded.
That’s the submission story in one line: a finished negotiation app where an open NVIDIA model plays the other side, Tavily keeps the market honest, and humans still own the floor.
Try it
- Open https://dealtable-webmcp.vercel.app → hard refresh.
- Commercial Lease Renewal → Target 45, Walkaway 40, Moderate → Start.
- Counter above walkaway → wait for Market check · Tavily (no Rule-engine fallback).
- Optionally open Advisor Insights, then push $39 to see the scoped waiver.
- Accept → skim summary and export the audit if you like.
What’s next
Ideas on the shelf after this entry: multi-advisor wiring beyond ChatGPT, persistence for returning sessions, document/PDF opening offers, and a longer-horizon “sealed mediation” experiment where each side uploads private walkaways and an agent finds overlap only at binding equilibrium. None of that is required for the Nebius cut — the live room is enough.
DealTable — you set the walkaway. Agents negotiate inside it.















