Pitwall Radio

Inspiration

Watching a Grand Prix always involves missing somethings, like the broadcast showing another battle further up the grid, or a safety car comes out while you look at your phone. A race engineer tells the driver only what matters, when it matters, and answers follow-ups in context. Pitwall Radio gives a fan that engineer.

What it does

Tell your engineer what matters. It watches the race, explains meaningful changes and follows up.

• Delegated watches. "Watch Leclerc versus Antonelli. Tell me if the gap drops under three seconds or either pits." The model only turns the request into a validated watch; the server evaluates it on every timing update and reports on the radio when it fires.
• What-ifs with follow-through. A pit estimate is remembered. A safety car invalidates it out loud, and when the real stop happens the engineer compares the outcome with its estimate.
• Away mode. "I'm stepping away, only interrupt me for a safety car." Everything else lands as silent cards, and coming back gets a before-and-after briefing.
• Explainability. Every alert and estimate keeps its reason and evidence; the Why button on a card shows them.
• Proactive radio. Stops, flags, lead changes, retirements, fastest laps, pit windows opening and cars closing in are announced unasked, rate-limited so the engineer never gets chatty.
• Reasoning from the race's own data. Settled pace, closing rates, a tyre degradation model fitted live on this race's clean laps, pit windows, undercuts and cliffs, each spoken with its sample size and assumptions. Nothing is pre-trained.
• Memory and context. Followed drivers and notes persist; "and his tyres?" works because the last driver is remembered; ambiguity gets "which driver?" rather than a guess.

Everything is exposed as 16 MCP tools and two resources over Streamable HTTP; proactive alerts are standard resource-update notifications on a subscribable resource. The companion page is a simulated Alexa+ client that talks to the server only through that interface, with push-to-talk and spoken replies through the browser's speech APIs.

It is built for live races: with the Interval desktop app and OpenF1 live access it follows the timing in real time. For judging, bun run demo replays the 2026 Singapore Grand Prix from lap 37 at a fixed 4x, with no playback controls, so the key moments arrive within minutes. The conversation runs on Claude Haiku 5.5 or any OpenAI Responses endpoint; timing, radio calls and the MCP tools work without a model.

How we built it

Bun, TypeScript and Effect; the official MCP SDK with a Streamable HTTP transport; SQLite for profile, notes and alerts. Race data comes from Interval, an open-source native F1 dashboard, over loopback; two pull requests to it during the hackathon made its backend discoverable and its replay seekable for any companion tool. The predictive layer is pure functions over laps the screen has already shown: a two-way fixed-effects fit for degradation, Theil-Sen slopes for closing rates and a declared time-gap model for pit stops, validated by replaying the whole race (bun run validate). Kiro Crew worked from the specs under .kiro/specs/ and fixed the ChatGPT sign-in flow from a written brief, transcript included. 247 tests, including a real MCP round trip in which an idle subscribed client is woken by a resource notification.

Challenges we ran into

• Formula 1 put its timing archive behind F1 TV authentication mid-hackathon; Singapore was ingested through Interval's updated sign-in and bundled so judges need no subscription.
• The MCP SDK's McpServer advertises resource subscriptions but does not register the handlers; they had to be added on the low-level server.
• Per-car gaps update at different timing loops, so a battle gap flickers by seconds; a watch only fires once a crossing has held for 20 s of race time.
• Keeping a replay demo reflective of actual use: nothing past the cursor reaches a tool, an alert or the model, and a restart clears the conversation.

Accomplishments that we're proud of

• The engineer reasons from the race in front of it. The degradation curve, pit windows and closing rates are fitted live from this race's own laps and spoken with their sample sizes, and every call can be explained from a card.
• Delegation that holds up. A watch, a what-if or an away request is turned into validated server state once; the server then does the work on every timing update, and the model is only called when there is something to say.
• A judge can run the whole demo in two commands with no F1 subscription, and any MCP client can connect to the same server the demo page uses.
• Two pull requests to Interval that make its backend discoverable and its replay seekable for any companion tool, not just this one.

What we learned

MCP resource subscriptions are an invalidation signal, not a payload channel. Wall-clock rate limiting is the right budget for a voice channel. For a voice product the reply length matters more than the model: two short sentences with the detail in a card beat a paragraph.

What's next for Pitwall Radio

A full live-race run at the next session, MCP Apps rendering for the cards when Alexa+ supports it, and per-person driver context for shared households.

Built With

• anthropic
• bun
• effect
• kiro
• model-context-protocol
• openai
• rust
• sqlite
• tailwind
• typescript
• web-speech-api