JiuTuanZhuo 揪團桌

Group ordering, agent-native

Comment

Inspiration

Office group orders in Taiwan are rarely voluntary. Someone gets picked to ask everyone what they want, and that person has often never run a group order before. After a wall of "+1" messages in the LINE group, figuring out who ordered what, who changed their mind, and who hasn't paid lands entirely on them. JiuTuanZhuo was built for that person: open a table, drop the link, let the system handle the rest.

What it does

The official website of 油庫口蚵仔麵線 (Youkukou Oyster Vermicelli) now has a built-in "open a table" feature. The host gets a private link; only people with the link can order. Everyone orders from their own phone, every view syncs in realtime, and the host always sees the current combined order. Tables are fully isolated: three companies can each open a table at the same time without their orders mixing. Humans order through the UI; agents order through WebMCP tools declared on the same page.

How we built it

Lovable (React) + Supabase (anonymous auth, RLS, RPCs, realtime). The frontend is an interface, not a boundary: pricing, item validation, and permissions are all enforced in Postgres RPCs under RLS, so agents and humans go through the same rules.

The page declares three WebMCP tools:

  • get_table_status: marked readOnlyHint, returns structured JSON, with user-entered fields wrapped as user_content so they are treated as data, not instructions
  • add_order: writes require an on-page human confirmation before execution
  • close_table: registered only in the host's session; other participants' agents never see this tool

All tools unregister when the table closes.

Challenges we ran into

The hardest part came first: breaking "+1 in a LINE group" into three actions (open, order, close) and deciding which rules belong in the database layer rather than the frontend.

The second was environment setup: getting Chrome to actually call the WebMCP tools on the page took a fair amount of configuration and debugging.

The third was pinning down where the latency actually lives. Measured on the page, tool execution is in the millisecond range: read tools return frontend state directly in 0.1–0.3 ms; write tools take 498 ms on the first call and settle at 66–72 ms after that. End to end, one order still takes about a minute. The gap sits entirely in the browser-side agent's tool discovery and reasoning; the page implementation itself is not the bottleneck.

Accomplishments that we're proud of

This is a 40-year-old street-food institution, and the second-generation owner built the system herself with AI vibe coding, so that customers' agents can place orders directly. Planning, architecture, and deployment were all done in-house, with no outside software vendor and no engineering team. The shop is the test bed: what gets built one day is in front of real customers the next.

What we learned

When the goal is clear enough, AI can build it. Writing code is not the barrier; knowing whose problem you are solving is.

What's next for JiuTuanZhuo 揪團桌

First, reshape the flow around how people in Taiwan actually buy: separate pickup and delivery after an order comes in, and print tickets straight to an IoT kitchen printer. Then, service by service, connect Google Maps scooter-distance calculation, payment, the Lalamove delivery fleet, and e-invoicing, until every step from order to handoff is linked.

JiuTuanZhuo is the entry point. From here we build inward, one piece at a time, into a full internal operating system for the shop that agents can run directly, ending with the POS itself. Ordering, ticketing, payment, fulfillment, and invoicing on one shared data layer is what a real closed loop looks like.

Built With

Share this project:

Updates

Submission history