Beyond the Chat Box: What happens when you turn all the agents off
Post eleven of a series on what live audience engagement actually looks like when there's an AI team in the room.
We've spent ten posts arguing for the agents.
Setup that compresses event configuration into ninety seconds. Protect that handles moderation at machine speed. Engage that gives the moderator their attention back. Answer that closes the loop between question and answer. Report that turns the event into insight. The Orchestrator that coordinates them all. The dial that controls how much authority you've delegated. SOUL.md that defines the rules. The whole architecture, end to end.
This post is about what ReactLive is when none of that is running.
The Off configuration
There's a setting on every agent's dial called Off.
When every agent in the system is set to Off, the agents stop acting. The Orchestrator stops orchestrating. SOUL.md still exists but isn't being read by anything that does anything. The Auto-Answer Loop doesn't run. The Report Agent doesn't generate a recap.
What's left is ReactLive without AI.
This is, deliberately, still a complete event platform.
What ReactLive is without the agents
When the agents are off, ReactLive is a clean, fast, well-built engagement platform with the features you'd expect:
Live Q&A. Anonymous or named, configurable per event. Submissions appear in the feed in chronological order. The audience can upvote questions. The moderator can approve, hide, prioritise, or route to the speaker. This is the workhorse feature of any engagement platform, and it works fully without any agent assistance.
Polls. The host or moderator drops polls during the event. Multiple choice, open text, scale, ranking. Results display live or after the close. Audience participation is anonymous or named per the event configuration.
Reactions. The audience can react to what's being said in real time — emoji, sentiment markers, quick acknowledgements. Reactions appear as a live signal layer on top of the event. The host sees engagement in the moment without needing to interrupt for a poll.
Live transcript. The same Whisper-based real-time transcription that grounds the Answer Agent when it's running keeps producing the live transcript when the agent is off. Hosts get accessibility and reference; attendees get a live captions layer; post-event teams get a searchable record. The transcript is independent of the agents — it runs as long as the audio stream is running.
Moderator tools. The moderator's interface is the same whether the agents are on or off — the queue, the speaker context, the speaker prompt, the ability to highlight questions, the ability to send private replies, the ability to pull or restore submissions. The agents add automation on top; they don't gate the underlying tools.
The basic event lifecycle. Create event, configure access, share with audience, run the event, end the event, export the data. All standard. No AI required.
This is the floor. Below this is nothing — the empty room. Above this is what the agents add. Hosts who want a Q&A and polls platform with a live transcript can have one, and it's a good one, with the agents off.
Why we built it this way
There's a temptation, when you're building an AI-native product, to make the AI mandatory. The agents are the differentiator. The agents are the reason ReactLive exists. Surely the product should require them to be on?
We rejected that framing for two reasons.
Trust has to be earned. No host trusts an AI system on day one — and the ones who claim they do are usually the ones who'll panic the first time the agent does something unexpected. Hosts need a path into the product that doesn't require them to commit to autonomous AI before they've seen it work. Run an event with the agents off. See if the platform is solid. Then turn one agent on and see what changes. That's how trust gets built. A platform that requires the AI to function denies hosts that path.
The AI should add value, not extract it. The test of whether the agents are doing real work is whether the host notices their absence. If turning the agents off makes the platform feel obviously worse, the agents are earning their keep. If turning them off doesn't change much, the agents weren't really helping. By making the off-state a real, complete product, we hold ourselves accountable: the agents have to be visibly better than nothing, every event, on every dimension.
The result is a product where the agents are the differentiation but not the dependency. The platform stands on its own. The agents make it dramatically better. Hosts can adopt at the pace they're comfortable with, and the value of the platform never depends on a particular trust level.
Who runs ReactLive with the agents off
Three groups, in our experience.
Hosts running their first event. This is the most common case. A new host wants to try ReactLive without committing to anything. They turn the agents off, run the event, see how the moderator interface feels, watch the live transcript, look at the question feed. After one event, they've decided: this is a good platform, the moderator likes it, the audience experience is clean. Now they're ready to flip Protect to Suggest for event two and start the climb up the dial we walked through in post three.
Hosts running events where AI isn't appropriate. Some events shouldn't have AI in them. A memorial service. A small board meeting where every word matters and the room is too intimate for automation. A regulated event where legal hasn't approved AI involvement yet. A confidential customer roundtable where the host wants only humans hearing the conversation. These hosts use ReactLive's core platform — the live Q&A, the polls, the transcript — and leave the agents off intentionally. The product respects that.
Organisations adopting in stages. Larger organisations often want to roll out a platform broadly before extending it to AI-assisted use. The IT team approves the platform. The comms team approves the moderation workflow. The legal team approves the data handling. Each approval gate happens with the agents off, because the platform's core capabilities are what's being evaluated. Once the platform is approved across the organisation, individual teams can opt into agent-assisted events as their own use cases warrant. The off-state is what enables that staged adoption.
These three groups together are a non-trivial slice of our users. Designing the product around the assumption that most events run agent-assisted, but some don't, and the platform must be excellent either way is what makes ReactLive deployable in real organisations rather than just in demos.
What you give up
It's worth being honest about what you give up when the agents are off.
Moderation is manual. The moderator reads every submission. They make every decision. At forty submissions across an event, this is fine. At four hundred, it's the structural failure mode we covered in the Engage post — the moderator drowns. ReactLive without agents handles small-to-medium events well. It handles large events the way every other platform handles them: with the moderator overwhelmed.
No AI answers. Questions get asked, the speaker (or the host) answers them live, and that's it. There's no AI surfacing already-answered questions in the speaker's transcript. There's no auto-response to FAQ-style questions. There's no closing of the loop between submission and answer except by the human in front of the audience. For events with small audiences and high-context speakers, this is fine. For larger events, it means most submitted questions never get answered.
No engagement intelligence. Polls are pre-scheduled or triggered manually. There's no system watching for the moment to drop one. There's no clustering, no priority ranking, no audience sensing beyond what the moderator can do by hand. The event runs, but the depth of engagement is bounded by the moderator's bandwidth.
No automated recap. The host gets the raw data — transcript, question CSV, poll results — and writes their own debrief if they have time. Most don't. The recap that the Report Agent would have produced doesn't exist. The patterns across events that compounding analysis would have surfaced never get surfaced.
These tradeoffs are real. The platform without the agents is a good platform; the platform with the agents is a structurally different category of thing. Hosts who run permanently with the agents off should be running smaller, more intimate events where the tradeoffs don't bite — and they should know that's the choice they're making.
The progressive adoption argument
There's a pattern that runs through this whole series, and it's worth surfacing explicitly here.
Every part of the architecture is designed to be opt-in:
- The platform works with the agents off
- The agents work at Suggest before they work at Auto
- The dial is per-agent, not per-platform
- The dial is per-event, not per-deployment
- SOUL.md lets you encode the rules you trust the agents to follow
- The override pathway is always live
This isn't accidental. It's the answer to the central question of how AI should ship in production: not all at once, not all-or-nothing, not with a single switch the user has to flip. AI should ship as a series of incremental delegations, each one earning the next, each one reversible.
The off-state is the floor that makes the rest of the architecture trustworthy. Without a floor, the dial doesn't mean anything — every level is mandatory in some way, and "off" is a fiction. With a real floor, every level above it is a genuine choice, and the choice can always be unmade.
ReactLive without the agents is the floor. It's a good floor. It's a complete platform. And it exists specifically so that everything above it — the Setup Agent, the Protect Agent, the Engage Agent, the Answer Agent, the Report Agent, the Orchestrator, the dial, SOUL.md — can be adopted at the pace, in the order, and with the constraints that the host actually needs.
That's the deal. The agents are great. The agents are why we built ReactLive. And the agents are off whenever you want them to be.
Next up: Beyond the chat box — what we learned dogfooding ReactLive at our own town halls. The series finale: real numbers from MPIRE's own internal events, what we configured, what surprised us, what we kept, what we changed, and what we learned about audience engagement that no demo ever taught us.
Join the waitlist to get early access. Three free events. Locked-in pricing.
