Tag: Hackathon

DealTable – Nebius x NVIDIA Global AI Hackathon

Posted on Posted in shiel yuleTagged , , , Leave a comment

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.

A futuristic boardroom featuring a holographic projection of a man presenting market analysis data. A visibly outlined 'decision boundary' is marked on the floor, and a nearby console displays an 'authority key' and 'override' option.

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:

RoleWhoJob
PrincipalYouSet the mandate, counter, hold firm, accept. Own every line past walkaway.
CounterpartyNVIDIA Nemotron (via Nebius Token Factory)Plays the other side in character — landlord, vendor, buyer, claim adjuster, etc.
AdvisorDeterministic coach in the appLeverage, 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.

ScenarioTypical use
Commercial lease renewalTenant vs landlord on rent / sq ft — the Nebius demo path
Freelance scope reductionDay-rate or project fee when the brief shrinks
Salary offer reviewPackage negotiation with a hard floor
SaaS vendor renewalSeat price / term when procurement pushes
Residential rent renewalFlat rent vs landlord opening ask
Insurance claim settlementSettlement band with claim-side pressure
Used car purchaseBuyer vs dealer on sticker
Home renovation quoteQuotes 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

  1. Entrance — pick a scenario (or custom).
  2. Setup — set target / walkaway / concession → Start Negotiation.
  3. Hub — chat with the counterparty; counter above walkaway; hold firm; open sources.
  4. Optional Advisor Insights — leverage, tone, win-win cards (coach, not opponent).
  5. Below walkaway — scoped waiver modal: set a temporary floor and time window → Grant or Reject.
  6. 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

LayerChoice
UIReact 18, Vite 6, Tailwind, Lucide
Session stateIn-browser store (dealStore) — no login, no DB for the demo
DeployVercel (SPA + serverless api/*)
Counterparty LLMnvidia/NVIDIA-Nemotron-3-Nano-30B-A3B via Nebius Token Factory (https://api.tokenfactory.nebius.com/v1/chat/completions)
Market evidenceTavily search (@tavily/core, basic depth, up to 5 results)
FallbackDeterministic rule engine if the model/key/parse path fails
External agentsWebMCP tools via document.modelContext.registerTool
AdvisorPure 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

Flowchart demonstrating a deal negotiation process involving various tools and APIs, including a WebMCP integration, Vercel serverless functions, and external APIs for market checks and price negotiations.

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:

  1. On start — POST /api/market loads comps into the session.
  2. On each counterparty turn — generateCounterpartyReply searches 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.

A business professional in a suit sits across from a glowing, holographic humanoid figure. The professional holds a tablet, while digital data, including market price analysis and a monetary figure labeled 'WALKAWAY FLOOR,' is displayed between them in a high-tech office setting.

Design choices that mattered

  1. Split the roles. One chatbot as both “coach” and “landlord” muddies the demo. Principal / counterparty / advisor maps to how real deals feel.
  2. HITL on the page. Authority UI has to live where the human is — not buried in a tool response the model can ignore.
  3. Keys on the server. Token Factory and Tavily never ship to the client.
  4. Evidence in the thread. Market check belongs under the reply, not a separate dashboard judges won’t open.
  5. 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

  1. Open https://dealtable-webmcp.vercel.app → hard refresh.
  2. Commercial Lease Renewal → Target 45, Walkaway 40, Moderate → Start.
  3. Counter above walkaway → wait for Market check · Tavily (no Rule-engine fallback).
  4. Optionally open Advisor Insights, then push $39 to see the scoped waiver.
  5. 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.

What 2,500 Hackathon Entries Taught Me About Spines, Sky Maps, and Agentic Leases

Posted on Posted in AI, Leonardo.ai, projects, shiel yule, vulture cultureTagged , , , , , Leave a comment

The verdict for the WebMCP Challenge is out: 7,000 registered souls, roughly 2,500 submissions from over a hundred countries, all hammered together across ten caffeine-soaked days.

I don’t envy the judging panel. Staring at 2,500 competing agentic architectures is the sort of cognitive punishment usually reserved for low-level tech purgatory.

My entry, DealTable, did not place in the top ten. And genuinely? That is completely fine. It was feral, slightly unhinged to build, and I’m thoroughly glad it exists.

The Pitch for the Fast-Scrolling Class

DealTable is a negotiation clean-room for the coming agentic web.

You hand it a mandate: your target, your walkaway threshold, and precisely how far you’re prepared to bend before dignity gives up. A counterparty pushes back in the chat. ChatGPT sits in the corner, acting as your advisor by calling typed WebMCP tools directly on the live page—not by hallucinating UI elements or squinting at raw DOM trees like an exhausted temp at 3:00 AM.

The moment a deal crosses your walkaway line, Human-in-the-Loop trips the emergency brake. Everything worth dragging a counterparty into court over gets stamped into an audit trail.

I built it because the real dystopia lurking in our automated future isn’t a gleaming chrome skull crushing a ribcage; it’s an overly polite corporate agent cheerfully agreeing to contractual terms that quietly turn your mortgage into a multi-generational performance art piece.

I just wanted a room where the human still has a hand firmly on the shock collar.

A man with a beard and glasses sits at a wooden table holding a cup, next to an old computer displaying green text on the screen. The setting is dimly lit with technological equipment in the background.

The Gallery as a Free Masterclass

After the shutters came down, I went prowling through the project gallery. Some of the builds were legitimately intimidating: spatial editors, shared notebooks, medical viewers, and collaborative wedding seating charts where human and model stare down the same live artifact.

That is the high-water mark now.

Mandate taking the crown made absolute sense. They were playing in the exact same theoretical pool as DealTable—authority, boundaries, delegation, and who gets to touch what—but they took the mechanics a leap further. Instead of just slapping an apologetic “Click Approve to continue” prompt onto a static API list, the tool surface itself mutates dynamically as permissions are granted or stripped away. Authority expires, the tools evaporate.

That wasn’t just a win; it was an architectural lecture I sat in the front row for, taking furious notes.

My internal post-mortem was ruthlessly mundane:

  • The Pitch Video: Too many Scots-accented ums, not enough surgical ruthlessness. Lead in lockstep: Problem → Mandate → Tool Call → Human-in-the-Loop → Closure.
  • The Narrative: Lead with the visceral bleeding problem, not the plumbing. WebMCP is the pipeline; nobody falls in love with the pipe.
  • The Execution: V1 ran a rule-based counterparty so I could focus entirely on the advisor bridge. Honest engineering, but in a hackathon arena, the theatre needs to be agent-native from lobby to exit door.
A person leans against a stone pillar in a dimly lit, futuristic environment, surrounded by glowing holographic displays of celestial navigation, a scroll, a dungeon layout, and an adaptive floor plan. A sign on the wall includes a humorous quote about coffee.

Five Winners I’d Actually Boot Up (And One I Suspect Solved a Judge’s Mortgage Dilemma)

Two thousand five hundred entries generate an extraordinary amount of speculative noise. These are the five that sliced clean through it.

1. MASIL — The One That Actually Matters

Reconnecting Korean elders to creative life.

An agent suggests classic calligraphy references and surfaces Janggi moves via WebMCP, but leaves the brushwork and the completion of the game entirely to the elder.

This is the project I’d back in a noisy pub debate. Not because it had the most complex stack, but because the human stakes are palpable. Elders isolated at home, their creative universe contracting to the size of a glowing piece of glass. The agent isn’t stepping in to replace human volition; it acts as an errand boy to fetch the pieces of a world they can no longer easily walk out to, handing them back as tools for their own craft.

That is WebMCP with a moral compass: typed tools, a shared page, and basic human dignity preserved intact. It makes you feel slightly guilty that your own entry was built around defending freelance day rates.

2. Roque Nights — Built by Someone Who Looks at the Sky

A stargazing planner from an engineer at the Gran Telescopio Canarias.

The agent crunches seeing conditions, isolates the darkest nights, figures out what’s actually worth observing, and slews the interactive sky map into alignment while you sit back and watch.

Unreservedly brilliant. Zero slide-deck jargon about “agentic paradigm synergy.” Just an engineer who genuinely cares about photons, an automated assistant doing the tedious atmospheric arithmetic, and a shared visual map both are looking at. If you’ve ever stood in a freezing field at midnight wondering if it was worth hauling 20 kilograms of glass out of the boot of your car, you immediately understand why this exists.

3. Observatory — Unfortunate Name, Impeccable Dungeon Energy

A procedural map-maker for tabletop designers and weary dungeon masters.

Type “a lonely crumbled watchtower in a choking swamp,” and the system doesn’t spit out a hallucinatory jpeg with six fingers. It generates structured, fully editable vector terrain, rooms, and labels through WebMCP.

If teenage me had been handed this, I’d have treated the monitor like a sacred religious relic. The beauty isn’t “the machine drew a landscape.” The triumph is that it created a manipulable environment that you and your gaming group can spend four hours arguing over. Rename it so it doesn’t sound like a venture-backed SaaS platform from 2013, and ship it.

4. Alza — The Antidote to Cynicism

A floor-plan editor that surrenders its tools directly to the model.

Feed it a single snapshot and one verified dimension; it traces walls, extracts spatial dimensions, and constructs a navigable 3D model you can stroll through in your browser.

This is the demo you pull out when a non-technical sceptic asks why everyone is screaming about agentic standards. It’s structure over pixels. The agent handles the tedious measurement math; the human remains the architect of the living space.

It has a grounded utility that makes DealTable feel like a late-night corporate philosophy seminar—which, let’s be honest, it essentially was.

5. ArchMorph — And the “Someone on the Jury is Renovating” Hypothesis

Fifty-seven distinct architectural tools, dynamic floor plans, and layout validation.

A staggering build. It’s also remarkably close in theme to Alza. When two distinct entries in a top-ten roster both revolve around floor plans, structural walkthroughs, and spatial clearances, one cannot help but suspect at least one member of the judging panel was mid-kitchen-extension and having an absolute nightmare with their contractor.

I’m not levelling accusations. I’m just saying if an investigative committee looked into it, I wouldn’t be surprised.

What Winning Actually Looked Like

The judges didn’t care about developers merely chanting “look, we registered seven API endpoints.”

They rewarded a single, shared artifact on screen—a celestial chart, a battle map, an architectural canvas, a digital calligraphy desk—and a division of labour where the machine acts as the grease and the human remains the spine.

DealTable v2 is already queued up on the local machine. The spine stays; the execution gets sharpened with the lessons pulled straight from the winners’ circle.

For the curious or the brave:

A massive tip of the hat to the WebMCP organisers (OpenAI and DevPost), the public builders, and my long-suffering collaborative stack that helped me figure out what needsHitl means in anger (including that brief, glorious window where DealTable accidentally attempted to negotiate commercial real estate at $undefined/sqft).

Huge congratulations to the winners—particularly Mandate. You set the bar.

#AllThingsAgentic Hackathon

Posted on Posted in Agile, Gemini, shiel yuleTagged , , , Leave a comment

I created this article for the purpose of entering the All Things Agentic Hackathon.

I built Tribunal Ally because I had to go to an Employment Tribunal myself. GOV.UK and Acas are there, but they do not hold your dates, letters, or chronology. You are left with a kitchen-table pile and a clock that does not pause for a grievance.

Tribunal Ally is a case file for that mess: check your position, keep evidence, draft a starting point for particulars, and read COT3 and settlement checklists with official links. It is not a law firm and it is not legal advice.

The agent is there for the drudgery. You upload a letter. It extracts dates and events. You confirm before anything is saved. Then the timeline updates. Collaborative, not a chatbot in a wig.

Built with Gemini 3.5, the Google GenAI SDK and ADK, Cloud Run, and Firestore, for All Things Agentic — track: Collaborative Partner.

Workplace problems, organised.

#AllThingsAgentic Hackathon