There is a distinct, uniquely contemporary brand of nausea reserved for corporate negotiation.

It usually begins on a Tuesday afternoon. You are sitting in the grey light of a laptop screen, staring at an email from an enterprise client whose signature line is longer than the Magna Carta. They want a thirty percent discount on your day rate. They are also proposing a payment schedule calibrated to conclude somewhere near the heat death of the universe.

Traditionally, you do what any self-respecting contractor does: you stare into the middle distance, do feverish mental arithmetic to calculate if you can survive on dry pasta until November, and draft a reply dripping with performative corporate politeness. You write, “Thanks for reaching out! Happy to find a middle ground,” while your spleen violently retracts into your ribcage.

The horror isn’t the money. The horror is the slow, wet erosion of your dignity in an unmonitored thread with no audit trail.

So, when the WebMCP hackathon opened with Devpost, I didn’t see an emerging browser protocol. I saw a containment unit. I decided to build DealTable: a clean, sterile room where synthetic entities could barter for scraps of my mortal labour, strictly supervised by a digital shock collar.

The Mathematics of Keeping Your Spine

In modern software architecture, people are terrified of artificial intelligence turning rogue, seizing missile silos, and sterilising the biosphere.

Personally, I am far more terrified of an AI agent negotiating a vendor contract on my behalf and cheerfully agreeing to a 90-day Net payment term because its sentiment-analysis model mistook predatory procurement tactics for “a collaborative synergy opportunity.”

To prevent the machine from liquidating my mortgage in the name of algorithmic politeness, DealTable relies on an ancient, barbaric concept: The Mandate.

Before you let the silicon speak, you set your floor. The target price. The concession tolerance. And, crucially, the walkaway limit ($w$).

The governance model is brutal:

$$\operatorname{apply}(p) = \begin{cases} \text{execute immediately}, 
& \text{if } p \ge w \\ \text{require human approval}, & \text{if } p < w \end{cases}$$

If the counterparty proposes an offer above your floor, the machines trade pleasantries and execute. The moment an offer dips even a fraction of a penny below your survivable threshold, execution freezes. The machine stops dead. It turns its digital head, looks you dead in the eyes, and demands an explicit, verified click: Approve or Reject.

Agents may hallucinate poetry, optimize supply chains, or pretend they have souls. But they cannot cross the floor. The human still owns the boundary.

Inside the Terrarium: How DealTable Operates

I built DealTable on a lean, serverless spine: Vite, React, and Tailwind, hosted on Vercel with local session state. No heavyweight databases or enterprise middleware—just pure client-side orchestration so hackathon judges could witness algorithmic bartering without signing their lives away to an authentication provider.

The secret sauce isn’t prompt engineering. It’s the Model Context Protocol (MCP).

Instead of treating an LLM like an omniscient wizard squinting at screenshots through brittle DOM automation, DealTable turns the browser window into a strictly typed operating theater. The page registers seven dedicated WebMCP tools:

• get_deal_state: Ingests the current mandate, active asking price, conversation history, and live metrics.
• set_mandate: Reconfigures the operational boundaries when market conditions sour.
• parse_opening_offer: Strips incoming corporate jargon down to cold, quantifiable digits.
• propose_offer & concede: Executes calculated counter-punches within authorized bounds.
• hold_firm: An programmatic, polite equivalent of a flat refusal.
• accept_term: Executes the closing sequence behind a cryptographic gate.

When ChatGPT acts as the advisor, it isn’t guessing. It is pulling live, validated state from the page and calling specific, sandboxed functions. When an action threatens the walkaway limit, the tool returns needsHitl.

A high-contrast Human-in-the-Loop modal slams over the viewport. The underlying JavaScript promise refuses to resolve until an actual warm-blooded creature clicks a button. The advisor is held in suspended animation, trapped in execution limbo while the human decides if the insult is tolerable.

Blood on the Terminal

Building autonomous negotiation arenas sounds pristine until you actually wire the pipes and watch the plumbing back up.

First came the bureaucratic indignities. Vercel threw an existential fit because a project repository contained capital letters and whitespace. A rogue hash mark sitting inside an npm run build command quietly sabotaged the Vite bundle like a loose bolt dropped into an aircraft turbine on deadline day.

Then came the existential bugs. During early test runs, our HITL modal inadvertently ingested an unparsed response object instead of the clean pending price structure. The result? A triumphant, unhinged bot proudly locking in a commercial lease for precisely $undefined/sqft. A dystopian victory for zero-cost real estate, perhaps, but tricky to defend in an audit.

Worse, demoing the workflow in real time created a bizarre psychological standoff. Triggering HITL via an active WebMCP tool call paused ChatGPT indefinitely, waiting for a human click on the host page. On a three-minute video recording, an AI staring wordlessly into space looks less like cutting-edge governance and more like catastrophic system failure. We restructured the demo rail to demonstrate deterministic tool execution in parallel with manual override triggers—making the safety rails obvious without subjecting the judges to awkward digital silence.

What the Silence Taught Me

We emerged from the hackathon with a working URL, a live audit export, and a few stark truths about the coming synthetic economy:

1. Typed tools beat automated vision every single time. Letting an LLM scrape a webpage to make financial decisions is digital negligence. Forcing it to call strictly typed, validated tools that mutate isolated state is the only way to retain sanity.
2. Never give one bot two jobs. In our early drafts, a single LLM tried to play both the cutthroat vendor and the impartial advisor. It rapidly degenerated into a schizophrenic pantomime where the model essentially negotiated with its own hallucinations. You must separate the actors: the principal sets the mandate, the counterparty pushes their agenda, and the external advisor sits outside the transaction.
3. The safety switch cannot hide in a sub-menu. If human oversight is buried three clicks deep or masked behind opaque JSON logs, it doesn’t exist. HITL belongs front and centre—a flashing, unavoidable perimeter wire.

The Road to the Silicon Souk

The prototype works, but the future is significantly weirder.

Next comes swapping out our deterministic, rule-based adversary for a fully conditioned LLM adversary—one capable of simulating specific, predatory procurement personas (the Passive-Aggressive Startup Founder, the Enterprise Bureaucrat with Infinite Runway, the Venture-Backed Lowballer). After that, automatic parsing of 80-page commercial PDF contracts, stripping away the legalese to find the hidden clauses that usually bite you six months later.

Ultimately, we are barrelling toward an internet where autonomous agents will spend their days aggressively bartering with other autonomous agents over micro-transactions, service level agreements, and server runtime fees.

If we don’t build deterministic floors into the code now, we will wake up in a decade to discover our synthetic representatives have cheerfully traded away our rights, our margins, and our weekends—all to achieve a 98% polite closure metric.

I’d rather keep the walkaway limit in React state, thanks. At least when the world ends, my console will log the exact price at which I refused to sell out.

#Devpost #DealTable #WebMCP #Vercel #netlify