LineLab — Rehearse the Rush

LineLab — Rehearse the Rush

LineLab helps event organisers rehearse a crowd rush before real guests arrive.

An organiser enters simple event facts such as guest count, doors, security staff, registration desks, pre-registration rate, backstage crew, and programme timing. LineLab then models the flow from gate to hall, identifies where people will get stuck, and lets an AI agent safely test possible repairs.

The important part: the agent can prepare, compare, and stress-test a plan, but it cannot make the final change. The organiser must visibly review and approve it.

The problem

A concert, college fest, or conference can become chaotic when too many people arrive at once. Registration may be slow, a QR scanner may fail, security may be understaffed, or the stage may not be ready when doors open.

Usually, organisers find out about these problems only when the real crowd is already waiting.

LineLab lets them ask: “What happens if this goes wrong?” before the event starts.

How it works

1. Enter a fictional event scenario.
2. Run a baseline rehearsal to see the current average wait, maximum queue, and bottleneck.
3. Ask the agent to create several safe draft repairs.
4. Compare the before and after results in plain language.
5. Stress-test the chosen plan against a disruption, such as a QR scanner failure or an arrival surge.
6. The organiser approves the final plan themselves.

For example, LineLab may show that Registration is the bottleneck because guests arrive faster than the team can check them in. It can then test a QR express line, arrival windows, a manual help desk, an extra entrance, or staff reassignment — and explain the trade-offs.

Why WebMCP matters

A normal chatbot can suggest “add more staff” without understanding the actual event state.

LineLab exposes structured WebMCP tools through document.modelContext.registerTool, so a WebMCP-enabled agent can work with the real scenario inside the product instead of guessing where buttons are on the screen.

The agent can:

• inspect the event flow and limits;
• configure a fictional scenario;
• run the baseline rehearsal;
• create a draft repair;
• compare outcomes;
• stress-test a disruption;
• commit a plan only after visible human approval.

This makes the agent useful, testable, and accountable. The organiser stays in control.

How we built it

LineLab is a Next.js and TypeScript web application with an interactive event-flow model. The model uses fictional data only; it does not use personal data, contact real venues, or make bookings.

We built the interface around plain-language explanations because an event organiser should not need to understand queueing theory to understand a problem. Instead of only showing numbers, LineLab explains what each result means, why a bottleneck occurs, and what would change in a proposed repair.

Challenges and what we learned

The biggest challenge was avoiding a fake “AI demo.” We wanted the product to do more than display a static answer. Each repair is calculated from the current scenario and must respect practical guardrails such as volunteer limits, doors, security, registration capacity, and pre-registration.

We also learned that human approval is not a small detail. The best agent experience is not an agent that silently changes everything; it is an agent that shows its reasoning, makes the trade-offs clear, tests failure cases, and lets a person make the final call.

What’s next

Future versions could support richer venue layouts, staff shift planning, accessible routes, live check-in signals, and post-event learning — while keeping organisers in control of every real-world decision.

Built With

• chatgpt
• crowd-safety
• css
• event-management
• html
• human-in-the-loop
• javascript
• next.js
• openai
• react
• simulation
• tailwind-css
• typescript
• webmcp