Hosting an Agentic Gathering

How to run a Sponic Agentic Gathering with the AI host. Two flows live in production: the original operator-driven flow (admin curates the roster from the intranet console) and the new self-enroll MVP (guests pick from a list of active Agentic Gatherings on the Android app and someone says “let's start” to begin). The MVP layer adds anecdote-grade onboarding interviews, host-only dossiers, and reactive nudging — built specifically to test whether the AI can produce demo-worthy contextual nudges.

What's new (May 2026 MVP)

If you remember the Agentic Gathering host as "operator opens a console, types in a roster, clicks Start" — that still works. What's new on top:

1. The onboarding interview produces real material now. The AI interviewer no longer asks for tags ("hiking, software, jazz"). It probes for anecdote-grade stuff — specific stories, opinions, current obsessions, life chapters. The kind of thing a thoughtful Agentic Gathering host would imagine retelling.
2. Each guest gets two derived artifacts. A user-visible profile (clean, sanitized, shows up under "From your AI interview" in the Android Profile screen) and a host-only dossier (richer, with concrete hooks the host weaves into Agentic Gathering conversation). The user sees their profile but not the dossier; the AI sees both.
3. The host actually uses the dossiers. When an Agentic Gathering starts, every present guest's dossier is injected into the host's system prompt. The host is told to default silent, only speak on triggers (lull / quiet guest / topic exhaustion / lobby), and bridge from the current conversation to dossier hooks rather than recite them.
4. Self-enroll lobby on Android. "Join an Agentic Gathering" in the Avatar menu now shows a list of active Agentic Gatherings (lifecycle lobby_open or in_progress). Tap one, you're in the room. While in lobby_open, the host greets arrivals warmly and waits for someone to say "let's start" — at which point it transitions the event to in_progress on its own.
5. Lifecycle column on dinner_events. scheduled → lobby_open → in_progress → ended drives the new behavior. The legacy status column (draft|live|ended|cancelled) is preserved so the operator console keeps working — both columns coexist.

Full spec: Agentic Gathering host — MVP for first contextual-nudge test. The build journal at the bottom of that page is the source of truth for what's deployed.

Who this guide is for

The operator running a Sponic Agentic Gathering — the person who configures the event in the intranet, opens the table-display page on a TV/iPad, and watches the conversation unfold. Operators must have the host_dinner permission (granted by default to admin, oracle, and staff roles). If you're an engineer trying to deploy or modify the AI agent itself, see Agentic Gathering Host instead — this doc is the operator manual, that one is the implementer manual.

What's an Agentic Gathering event?

A row in public.dinner_events. One row per Agentic Gathering. The row owns:

• Identity — label (“Friday catgirl test”, “Sonia's Mar 12 Agentic Gathering”), date, and operator notes.
• Two state columns. status = legacy operator-flow state (draft|live|ended|cancelled). lifecycle = MVP self-enroll state (scheduled → lobby_open → in_progress → ended). Both coexist; the operator console reads status, the AI agent and Android lobby read lifecycle.
• Lifecycle timestamps. lobby_opened_at, started_at, ended_at — stamped automatically on transition, never overwritten.
• Configuration snapshot — the persona (dinner_host, tea_party, or interviewer), Gemini voice, Simli face_id, and any per-session prompt override. Frozen at Start.
• Roster — which app_users are participating (one row per participant in dinner_event_participants). Joined/left timestamps fill in automatically; the new session_status column tracks lobby / active / left for the MVP flow.
• Runtime data — every transcript turn (dinner_event_transcript), every lifecycle/error log line (dinner_event_log, including the lifecycle: X → Y entries written by the lifecycle endpoint), aggregate metrics (duration, Simli cost, turn count) filled at End.

The LiveKit room is an implementation detail (dinner-{event_id}-{epoch}). The event is the human-meaningful unit you can return to days later — full transcript still queryable, configuration still readable, costs still attributed.

Per-user data — three tables you should know

• public.onboarding_interviews — every interview anyone has done. transcript_messages + transcript_text, status (in_progress | completed | extracted | abandoned), supersedes_id when a user re-runs the interview.
• public.user_profiles — user-visible profile (one row per app_user). Sanitized fields the user sees in the Android Profile screen: intro_one_liner, interests[], what_im_into, whats_new, pronouns.
• public.user_dossiers — host-only character sketch + hooks. Hooks are the bridge material the host actually uses: {type, title, content, comfort}. Locked to admin/oracle on read because comfort: personal hooks aren't meant to be casually browsable.

The flow at a glance

A · Self-enroll MVP flow (recommended for the personalization test)

1. Each guest completes the v2 interview from the Android app's Avatar menu → "Get an Onboarding Interview." 10–15 minutes per guest. Done once, ahead of the Agentic Gathering — they can re-run it from the Profile screen later.
2. Operator opens a lobby by transitioning a dinner_events row to lifecycle='lobby_open'. From the intranet console: create the event, then call the lifecycle endpoint (or use the operator's "Open lobby" button when it lands). The room is created with lifecycle='lobby_open' and the AI host enters welcome mode.
3. Guests open Sponic on Android → Avatar menu → "Join an Agentic Gathering" → tap the active Agentic Gathering from the lobby list. They land in the LiveKit room with their mic on. The host greets each new arrival warmly and makes light small talk while waiting.
4. Anyone says "let's start" / "we're all here" (or similar — the trigger is a regex over user transcripts; see below for the full pattern). The host detects it, calls the lifecycle endpoint to flip lobby_open → in_progress, and opens the Agentic Gathering with a thread pulled from one of the dossier hooks.
5. Agentic Gathering runs. Host stays mostly silent, intervenes only on lull / quiet guest / topic exhaustion, weaves dossier hooks into the existing conversation rather than reciting them. Two-sentence-max replies. Reactive, not directive.
6. Operator clicks End when the Agentic Gathering wraps. Room is deleted, aggregates computed, event row freezes at lifecycle='ended'.

B · Operator-driven flow (legacy, still supported)

The original flow, unchanged. Use this for events where you want full control over the roster and don't need self-enroll. Use Flow A for the personalization test specifically.

1. Operator opens /en/gatherings on a laptop or phone and clicks + New event. Sets a label and date; adds participants from the app_users roster.
2. Operator picks configuration — persona / voice / face. Optionally toggles Override prompt for this session to hot-edit the system instructions sent to Gemini Live.
3. Operator clicks Start. The system creates a LiveKit room with the chosen overrides baked in as room metadata, transitions the event to status='live', and returns a host URL.
4. Operator opens the host URL on the table display (a TV / iPad / laptop set at the head of the table). The page subscribes to the room and renders the Simli avatar full-screen. AI audio plays from this device's speakers.
5. Participants in Speak+View on their phones auto-join the Agentic Gathering room as mic inputs. Each phone publishes its own mic; the agent receives the room mix.
6. The AI host greets the table in the configured voice and replies in the language of the most recent speaker. Conversation flows.
7. Operator clicks End in the console. The room is deleted, aggregates are computed, the event row freezes with the full transcript and cost.

Setting up the personalization test

Step-by-step from "I just heard about this" to "we ran the test Agentic Gathering." Assumes you have an intranet login (you can see /en/gatherings without a 403). If the people you're inviting don't have the Android app yet, get them onto the latest APK first — see Mobile builds.

Step 1 — invite guests and have them complete the new interview

The dossier-driven host only works if your guests have done the v2 interview. Old app_users.dinner_profile blobs from the legacy interview won't auto-extract into user_dossiers — guests need to run it again on the new prompt.

1. Tell each guest: "Open Sponic on Android → tap your avatar (top right) → Get an Onboarding Interview. It's about 10–15 minutes. The AI is collecting specific stories and opinions, not generic interests — answer like you're catching up with a curious friend, not filling out a survey."
2. If they've already done a legacy interview, they can re-run from My Profile → Redo your interview. The new run supersedes the old one in onboarding_interviews.
3. If the app still shows an existing profile and you need to force a clean redo, use Admin → Interviews. Search for the user and click Reset interview. That marks their latest interview abandoned, clears the visible profile and host dossier, and removes the legacy transcript blob so the next Android interview starts cleanly.
4. After they wrap, the agent saves the transcript and fan-outs to two extraction pipelines: the legacy one (populates app_users.dinner_profile.*) and extract-host-mvp-profile (populates user_profiles + user_dossiers). Costs ~$0.003/extraction on Gemini 2.5 Flash.

Step 2 — verify each guest's dossier landed

Before you spend an evening on the Agentic Gathering, confirm the extractions actually produced material the host can work with. From a psql shell against the production DB (see runbook → Supabase backup pooler access for the recipe):

-- For each guest you just interviewed:
SELECT
  au.display_name,
  oi.status              AS interview_status,
  jsonb_array_length(ud.hooks)   AS n_hooks,
  ud.character_sketch,
  up.intro_one_liner,
  array_length(up.interests, 1)  AS n_interests
FROM public.app_users au
LEFT JOIN public.onboarding_interviews oi
  ON oi.app_user_id = au.id AND oi.status = 'extracted'
LEFT JOIN public.user_dossiers ud  ON ud.app_user_id = au.id
LEFT JOIN public.user_profiles up  ON up.app_user_id = au.id
WHERE au.email IN ('alice@…', 'bob@…', 'carol@…')
ORDER BY au.display_name;

What good looks like:

• interview_status = 'extracted' for everyone.
• n_hooks ≥ 3 for everyone. Fewer than 3 means the interview didn't surface enough specific material — ask them to re-run.
• character_sketch reads like a real description of the person, not a generic blurb.
• intro_one_liner would be reasonable as a one-sentence intro at the Agentic Gathering.

Spot-check by tapping into the Android app as that user and opening My Profile. The "From your AI interview" card at the top should show the intro one-liner, what-I'm-into, what's-new, and interest chips. If the card says "Couldn't load" — auth or extraction issue; check the edge-function logs at supabase dashboard → functions.

Step 3 — create the event and open the lobby

Create the event from the operator console, add participants, set persona to tea_party, then put the row in lobby_open state before the agent joins. The Android lobby list requires lifecycle in ('lobby_open','in_progress'); the agent's start trigger arms only if it sees lobby_open at job start.

# Replace bw-fields/auth as appropriate. SUPABASE_SERVICE_ROLE_KEY is in BW
# item "Supabase — SponicControl Project" → "Service Role Key".

# 1. Create the event in draft (operator console: + New event) and add participants.
#    Or directly:
INSERT INTO public.dinner_events (label, persona, voice, face_id)
VALUES ('Personalization test 2026-05-09', 'tea_party', 'Aoede', NULL)
RETURNING id;

# 2. Transition to lobby_open via the lifecycle endpoint:
curl -X POST "https://xumcmantignrocihtrdx.supabase.co/functions/v1/dinner-event-lifecycle-update" \
  -H "Authorization: Bearer $SUPABASE_SERVICE_ROLE_KEY" \
  -H "Content-Type: application/json" \
  -d '{"dinner_event_id":"<uuid>","lifecycle":"lobby_open","reason":"opening test"}'

The endpoint stamps lobby_opened_at, writes a row to dinner_event_log for forensics, and is idempotent (calling it twice is a no-op).

After the row is lobby_open, click Start event in the operator console. That creates the LiveKit room, fills livekit_room_name, dispatches the named sponic-dinner-host worker, and returns the table-display URL.

Step 4 — guests join from Android

1. Each guest opens the Android app, taps their avatar (top right), picks Join an Agentic Gathering.
2. The lobby list shows your event with a green "Lobby open" pill, label, and the names of guests already there.
3. They tap Join, get dropped into the LiveKit room, mic on. The Simli avatar / Gemini voice greets each new arrival.
4. The host stays in welcome mode while waiting — light small talk, low pressure.

Step 5 — start the Agentic Gathering with a natural-speech trigger

Once everyone's in the lobby, anyone says one of these out loud:

• "Let's start." / "Let's begin." / "Let's get going." / "Let's do this."
• "We're all here." / "We're ready." / "Everyone's here."
• "Should we start?" / "Shall we begin?" / "Can we get going?"
• "I think we can begin." / "I think we should start."

The agent watches user transcripts for these phrases (case-insensitive) and fires dinner-event-lifecycle-update on the first match — transitioning lobby_open → in_progress, stamping started_at, and the host opens with a thread pulled from a hook with comfort: public. The trigger disarms after firing, so a second "let's start" later in the Agentic Gathering won't re-fire.

If the trigger doesn't fire (false negative), you can flip the lifecycle manually with the same curl call — set lifecycle: "in_progress".

Step 6 — observe + score

Run for 60–90 minutes. As the Agentic Gathering unfolds, score against the success criteria. Bring a notebook (or a co-observer who isn't trying to also be a guest):

• Demo-worthy nudges — every time the AI bridges to specific dossier material in a way a guest would notice. Target ≥3 in a 90-min Agentic Gathering.
• False interventions — the host speaks when nobody wanted it to. Target <1 per 30 min.
• Bridge specificity — when the host intervenes, does it reference concrete dossier content or just generic small talk? Target ≥60% concrete.
• Lobby trigger reliability — count "let's start" attempts vs successful triggers. Target 100% across ≥5 attempts (try with multiple speakers, different phrasings).

Step 7 — debrief and journal findings

Findings go in the build journal of ai-host-mvp.md, not in the spec body — the prompts evolve, the spec stays a snapshot of intent. Useful things to capture:

• Lull threshold tuning. Spec defaults to ~8s; if you observed the host jumping in too eagerly, try 10–15s. If lulls felt awkward, try 6s. Editable in apps/ai-host/persona.py.
• Whether to ever name guests directly when bridging. Current default: never. If a quieter guest noticed they were being included gracefully, note that — the bridge is working.
• Any "personal" hook the host bridged to in a moment that felt off. Comfort tagging needs tightening.
• Specific bridges that landed well — quote them. They're the demo material for the next round.

Before the Agentic Gathering (pre-flight)

1 · Confirm operator access

Sign into the intranet at in.sponicgardens.com and load /en/gatherings. If you see the events index, you have host_dinner permission. If you get a 403 or blank page, your app_users.role isn't in the granted set — ask an admin to promote you, or grant a per-user override on user_permissions.

2 · Pick devices

An Agentic Gathering uses three roles, on three different devices:

The operator console can run on the same device as the table display, but it's clearer to separate them — the operator wants to monitor the transcript and diagnostics; the table wants the avatar full-screen.

3 · Pre-add the participant roster

Every guest needs an app_users row. The Edge Function livekit-token auto-provisions a row with role public on first sign-in, so guests can self-onboard via the Android app's Google Sign-In. After they've signed in once, find them in the operator console's roster picker and add them to the event.

Participants who aren't on the roster of a live event will not be able to publish mic into the Agentic Gathering room — the livekit-token Edge Function returns 403 not_on_event_roster.

4 · Confirm internet

The AI host runs on LiveKit Cloud — every device needs solid Wi-Fi or LTE/5G for the entire conversation. The table display needs steady downlink (avatar video is ~1–2 Mbps); participant phones need decent uplink for mic. A 5–10 second dropout will cause the AI to pause; a longer one drops the publisher.

5 · Mic placement

Multi-mic in this iteration: each participant's phone is a separate mic publisher and LiveKit auto-mixes them for the agent. Cleaner audio comes from:

• Each phone face-up on the table within 30–60 cm of its owner.
• Avoid stacking phones; mics interfere.
• Smarter mic gating (only the loudest speaker reaches the agent) is Phase 2 — for now expect overlapping voices to occasionally confuse the AI's language detection.

6 · Battery + charger

Plan on ~10–15% battery per 30 minutes per phone. Have chargers available; the host display especially should be plugged in for the duration.

7 · Pre-brief guests (optional but recommended)

Most guests have never talked to a real-time AI before. A 30-second framing helps:

• “This is Sponic — we have a wing-friend AI joining the Agentic Gathering. The avatar on the screen is the AI host. Each of your phones is its mic; just talk normally. The AI replies in the language you speak. The transcript is private to the operator.”
• Ask if anyone's not comfortable being heard. There's no per-guest opt-out short of leaving the roster, so consent is at the table-as-a-whole level.

At the Agentic Gathering (running it)

Starting the event

While the conversation is running

• Live transcript streams into the operator console in real time, attributed by participant. Each row shows speaker name, language, and the exact text Gemini transcribed.
• Diagnostics zone shows the LiveKit worker status, connected participants, Simli avatar minutes-so-far × $0.30, and any ERROR-level rows from the agent's log. Replaces SSH-tail-logs as the primary debugging surface during a session.
• Multi-mic in this iteration: LiveKit auto-mixes audio from all participant publishers — the agent receives a single mixed stream. Smarter mic gating is Phase 2; for now expect occasional confusion when guests overlap.
• Languages mid-flight: the AI's dinner_host persona replies in the language of the most recent speaker. Switching from English to Polish to Spanish works inline.
• Interrupting the AI: just start talking. The agent's barge-in detection cuts its own speech.
• Operator notes at the bottom of the event detail page autosave on blur — capture observations for later review.

Ending

Click End Agentic Gathering in the operator console. The system deletes the LiveKit room (which causes Phoenix to drop the agent job and Simli to stop billing), computes aggregate metrics (duration, cost, turn count), and freezes the event row at status='ended'. The table display returns to its idle silhouette.

After the Agentic Gathering

What gets saved

• The full event row in dinner_events — label, configuration snapshot, duration, Simli cost, transcript turn count, operator notes.
• Every transcript turn in dinner_event_transcript — speaker attribution, timestamp, language, full text.
• Every log line in dinner_event_log — Job started, Simli avatar started, errors, participant join/leave.
• Roster timestamps in dinner_event_participants — joined_at and left_at fill in automatically as each phone connects/disconnects.

What's not saved (yet)

• Audio recording — LiveKit's room audio is ephemeral; we don't archive WebRTC streams. Only the text transcript persists. (Recording would need a storage + retention + privacy review pass.)
• Per-guest profiles from a multi-guest Agentic Gathering — only the onboarding interview flow currently writes to app_users.dinner_profile. The Agentic Gathering host transcript captures everything but doesn't (yet) feed back into individual profiles.

Reviewing or re-running an event

Current limits & what's coming

What's now shipped, and what's still pending:

Full MVP spec: ai-host-mvp. Realtime stack: ai-host-livekit. AI-side architecture: Agentic Gathering Host.

Troubleshooting

Operator console returns 403 / blank page

Your app_users.role doesn't grant the host_dinner permission. Default grants are admin, oracle, staff. Either get promoted, or add a per-user override:

INSERT INTO user_permissions (app_user_id, permission_key, granted)
VALUES ('<your-app-user-id>', 'host_dinner', true);

Start Agentic Gathering button is disabled

You haven't added any participants to the roster yet. Click + Add participant; you need at least one before Start enables.

Table display stuck on “Setting the table…”

The avatar fades in once Simli starts publishing — that's ~1.5–2 seconds after Start. If you wait 10+ seconds and still see the silhouette, check the operator console's diagnostics zone:

• Worker not registered → Phoenix is down. SSH and restart per the runbook Agentic Gathering host section.
• Simli avatar started log row missing → Phoenix env may be missing SIMLI_API_KEY / SIMLI_FACE_ID. The agent runs voice-only when these are absent.
• ERROR row in agent log → read the message; it's likely a transient Simli or Gemini Live issue. End and re-Start.

Participant phone shows no in-gathering banner

• Confirm the user is on the event roster in dinner_event_participants.
• Confirm event status is live (the operator clicked Start).
• The Android my-active-event poll runs every ~10 seconds — first detection can take that long after Start.
• Confirm the Android build includes the Agentic Gathering-event extension (older APKs do not).

The AI answered in the wrong language

Gemini Live's auto-detect can guess wrong on short phrases. Speak a full sentence and it usually corrects itself within one turn. If it stays stuck, End the Agentic Gathering and Start a new event — the language hint resets.

Audio sounds robotic / chopped on the table display

Network jitter on the display device. Move closer to the router or switch to wired Ethernet if available. Simli avatar video is the bandwidth-heavy track; the AI voice itself is light.

Two voices talking over each other in the AI's response

Means a previous LiveKit room wasn't fully cleaned up before a new agent dispatched into the same name. Click End on the offending event, then Start a fresh one — Phoenix uses anonymous workers with exactly-once dispatch per room, so a clean Start should not collide.

I want to recover transcripts after End

Open the event detail page from the events index. Full transcript and log are persisted in dinner_event_transcript / dinner_event_log. There is no audio recording.

"From your AI interview" card on Android shows "Couldn't load: ..."

The card hits host-mvp-profile-get with the user's Google ID token. Common error codes:

• invalid_google_token — sign-out + sign-in. The cached token expired.
• network_error — offline or Supabase reachability problem.
• Card renders the empty state ("you haven't completed your onboarding interview yet") — user just hasn't done the v2 interview yet, OR the extraction failed. Check onboarding_interviews.status: if there are completed rows but no extracted ones, the extraction call failed — read function logs.

Lobby list shows "No active Agentic Gatherings right now"

The endpoint queries dinner_events filtered to lifecycle in ('lobby_open','in_progress'). If you opened the event but only flipped status='live' (legacy column), the new lobby UI won't see it. Call the lifecycle endpoint to set lifecycle='lobby_open' explicitly.

"Let's start" trigger didn't fire

Check the agent log (Phoenix VM, or dinner_event_log rows). Two common causes:

• The event wasn't actually in lobby_open when the agent connected. The trigger only arms if fetch_dinner_event_lifecycle at job start returned "lobby_open". If the event was created in scheduled, transition it via the lifecycle endpoint before any participant joins.
• The phrase you used didn't match the regex. Try one of the canonical patterns from Step 5. False-negatives are recoverable — flip the lifecycle manually via curl.

The host has zero context — speaks generically about everyone

Dossiers weren't fetched at job start. Check the agent's startup log for "Dossier fetch: requested=N returned=M". If requested=0, the participant metadata didn't include user_ids — token-mint flow issue. If requested>0, returned=0, the users in the room don't have user_dossiers rows yet — they need to complete the v2 interview, see Step 1.

Related docs

• Agentic Gathering host — MVP for first contextual-nudge test — the spec that drove this revision. Phase-by-phase build journal at the bottom is the source of truth for what's deployed.
• Agentic Gathering Host — implementer-side reference for the agent (architecture, deploy, monitoring).
• Agentic Gathering Host build plan — realtime stack roadmap.
• Mobile builds — current Android APK, future Mac DMG and iOS sideload.
• Live Translation Subtitles — companion feature, currently Android-only.
• Agentic Gathering runbook — venue ops checklist and member-prompt copy.