DealTable

• 

  DealTable_circle

• 

  DealTable_square

Inspiration

I’ve negotiated freelance rates, lease renewals, salary bands, and insurance claims the hard way: email threads, mental math on a walkaway number, and no clean trail when things went sideways.

The agentic web made that worse before it made it better. Assistants can draft counters and “help” close — but without a hard floor, they also help you accept the wrong deal. I wanted a practice room where:

1. You set the rules once (target, walkaway, concessions).
2. An open model plays the other side — not a canned script.
3. Market claims are grounded, not invented.
4. Anything past your floor stops for you.

That became DealTable: negotiate with a floor.

What it does

DealTable is a browser negotiation room (no login) for everyday scenarios — commercial lease, salary, insurance claim, used car, flat purchase (England & Wales), renovation quotes, and more.

• Mandate — target, walkaway, concession %. The rules of the deal before you enter the room.
• Counterparty — NVIDIA Nemotron Nano on Nebius Token Factory replies in character each turn.
• Market check — a live Tavily search on the same path; source links appear in the thread so comps are visible to judges and users.
• Advisor / WebMCP — optional ChatGPT calls typed tools on the page (propose_offer, propose_waiver, …), not DOM scraping.
• Scoped waiver (HITL) — below walkaway you get a card: edit floor + duration, then Grant or Reject. While a waiver is live, deeper tools appear; Revoke and they vanish.
• Close — summary, printable handoff docs, audit export.

The walkaway gate is deliberate. For a proposed price (p) and walkaway (w):

[ \text{apply}(p) = \begin{cases} \text{send to the table} & \text{if } p \ge w \text{ (or covered by a live waiver)} \ \text{human shapes a scoped waiver first} & \text{if } p < w \end{cases} ]

Agents can haggle. They don’t cross your floor without you.

Live: https://dealtable-webmcp.vercel.app
Repo: https://github.com/shielyule/dealtable-webmcp

How we built it

Stack: Vite + React + Tailwind, deployed on Vercel. Session state stays in the browser so anyone can try it without an account. Server path (API keys never in the client): turn → POST /api/counterparty 1) Tavily search (scenario-specific comps) 2) Token Factory chat completions (Nemotron Nano) → reply text + proposedPrice + sources on screen + audit Walkaway / waiver logic runs in the app before a below-floor move is treated as accepted. If Token Factory fails, a rule-engine fallback keeps the room usable; the UI can distinguish live model turns from fallback. What changed in this hackathon window: an earlier WebMCP build used a scripted counterparty. For Nebius × NVIDIA, that side became a live Nemotron call, with Tavily supplying the evidence the reply may cite — same negotiation shell, harder other side.

Challenges we ran into

1. Seller vs buyer economics — claim/salary deals negotiate up; lease-style deals negotiate down. Early logic “accepted” highs that were still wrong for the payer, while Current Ask lagged the chat. Fixing deal side and always syncing proposedPrice made Accept match the thread.
2. Nemotron output hygiene — Nano sometimes parked usable JSON in reasoning or leaked meta-instructions into “chat.” We parse content carefully, reject meta leaks, and only fall back to reasoning for parse — never as raw dialogue.
3. Tavily has to change the reply — a search that fires and is discarded doesn’t count. Snippets go into the prompt; titles/URLs stay on the Market check and audit.
4. HITL vs in-flight WebMCP calls — re-registering the tool surface mid-approval can abort the waiting tool. Refresh is deferred so Grant can return, then counter_under_waiver appears (Mandate-inspired scoped authority).
5. Production parity — localhost keys don’t help judges. Shipping meant Vercel env for Token Factory + Tavily, then a live smoke on the public URL.

Accomplishments that we're proud of

• A complete product loop, not a PoC: scenarios → mandate → live counterparty → comps → waiver → handoffs.
• Nemotron + Tavily on the real request path, with sources visible in-thread for the 3-minute video and for judges clicking around.
• Authority as a first-class UX: scoped waiver (floor + time) and a tool surface that changes on Grant / Revoke.
• Consumer scenarios people actually rehearse (salary, claim, car, flat) alongside classic B2B ones.
• Keeping WebMCP advisor tools without letting them bypass the human floor.

What we learned

• Authority is the product, not “we added an LLM.” Who may spend your walkaway matters more than how fluent the agent sounds.
• Grounding beats eloquence — a short reply with a Tavily link beats a long invented market story.
• Demo discipline — first 45 seconds should be problem + one live proof; one feature per sentence.
• Open models need an honest escape hatch — fallback is fine; pretending fallback is the entry is not.
• Reusing a strong shell (mandate, HITL, audit) and upgrading the counterparty was faster — and clearer for “what changed” — than rebuilding from zero.

What's next for DealTable

• Deeper mandate scopes (category caps, time-boxed spend, multi-currency floors) with the same Grant / Revoke theatre.
• Stronger seller-side and UK conveyancing paths (Scotland as its own scenario, not a toggle).
• Optional persistence so practice sessions can resume — without forcing login for the public demo.
• Sibling ideas that reuse the same governance pattern (e.g. checkout cooling / authorize-then-capture rails) while DealTable stays the negotiation practice room.
• Mirror critical controls server-side when real money or real contracts are on the line — the browser demo proves the shape; production needs the same rules behind the API.

Built With

• advisor
• ai-agents
• api
• chatgpt
• chrome
• hackathon
• human-in-the-loop
• javascript
• llm
• mcp
• model-context-protocol
• nebius
• nebius-token-factory
• negotiation
• node.js
• nvidia
• nvidia-nemotron
• openai
• react
• tailwindcss
• tavily
• token-factory
• vercel
• vite
• webmcp