Beyond the Chat Box: The Orchestrator doesn't outrank your moderator

Post ten of a series on what live audience engagement actually looks like when there's an AI team in the room.

There's a question we get asked at almost every demo, usually about ten minutes in, and it goes like this:

So when the AI is on Auto, my moderator just sits there?

The question is reasonable. The framing is wrong. And how we answer it has turned out to matter more than almost any other conversation we have with prospective customers — because the assumption underneath the question is the assumption that's kept event hosts from adopting AI in the first place.

Here's the assumption: if the AI is acting autonomously, the human is no longer in charge.

That's not how ReactLive works. It's not how the Orchestrator is built. And the gap between the assumption and the reality is the most important thing to be clear about in this whole series.

This post is the corrective.

What "Auto" actually means

Across this series we've used the word Auto a lot. Protect on Auto. Engage on Auto. Answer on Auto. Auto is the highest setting on every agent's dial — Off, Suggest, Assist, Auto.

It's worth being precise about what Auto does and doesn't mean.

Auto means the agent doesn't wait for human approval to act. When the Protect Agent is on Auto and a clearly abusive submission comes in, it gets blocked. The moderator doesn't have to click "approve block" first. The agent acts within the rules it's been given.

Auto does not mean the human can't intervene. At any moment, on any decision the agent has made, the moderator can override. Reverse a block. Edit an answer. Withhold a poll. Pull a question back from the public feed. Modify the SOUL.md mid-event to change the rules. The override pathway is always live, at every dial setting, including Auto.

Auto does not mean unsupervised. The moderator still sees what the agent is doing — every block, every answer, every poll, every escalation. They're not stepping through the queue, but they're watching the stream. The transparency doesn't change with the dial; only the requirement to approve changes.

Auto does not mean unaccountable. Every agent action is logged with a confidence score, the source material it drew on, the rule it applied, and the result. After the event, the Report Agent surfaces what each agent did. If something went wrong, you can trace exactly why.

The shorthand we use internally: Auto means the agent acts on its own judgment within the rules. Within the rules is doing all the work in that sentence. The agent doesn't make the rules. SOUL.md does. The moderator does. The host does. The agent operates inside that boundary, and only inside it.

What the Orchestrator does — and doesn't

The Orchestrator is the conductor of the agent system. It reads SOUL.md. It routes context between specialists. It holds the timeline. It decides which agent acts when.

It is not your moderator's manager.

This distinction is structural, not stylistic. The Orchestrator coordinates the agents — it doesn't sit above the moderator in a hierarchy. The org chart looks like this:

• The host runs the event
• The moderator runs the room (and overrides anything they need to)
• The Orchestrator runs the agents
• The agents run their specific jobs

The Orchestrator's authority extends downward to the agents, not upward to the humans. When the Orchestrator decides which agent should handle an incoming submission, that's an agent-coordination decision. When the moderator decides to override the agent's output, that's a human decision, and the Orchestrator routes around it without complaint.

A useful way to think about it: the Orchestrator is the moderator's deputy, not the moderator's boss. The deputy handles the routine coordination work — clustering submissions, routing context, deciding which specialist should look at what — so the moderator doesn't have to. But every meaningful judgment call still belongs to the moderator, and the Orchestrator's job is to surface those calls promptly, not to make them.

What override actually looks like

The word override gets used a lot, and it's worth being concrete about what it actually means in practice.

Reversing an action. The Protect Agent auto-blocked a submission. The moderator looks at it, decides it's not actually abusive, clicks restore. The submission appears in the feed; the block is reversed; the agent's confidence is logged for calibration. Total time: under five seconds.

Editing an output. The Answer Agent generated a response to a question and is about to publish it. The moderator sees the draft, notices the tone is slightly off — too formal for this room — edits it, publishes the edited version. The agent learns from the edit for future answers in the same event. Total time: ten seconds.

Withholding a publication. The Engage Agent surfaced a poll for auto-publish. The moderator decides the timing isn't right — the speaker is mid-thought — and clicks hold. The poll waits in the queue until the moderator releases it or skips it. Total time: two clicks.

Pulling a question. A question is in the public feed. The moderator realises it shouldn't have been there — maybe it names a specific employee, maybe it's a leaking question that the agent's policies didn't catch. They pull it. The question disappears from the audience view; it's preserved in the moderator's queue with the original submission for follow-up. Total time: one click.

Modifying the rules in flight. The room is more tense than expected. The moderator pulls up SOUL.md, edits the escalation rules to be more conservative, saves. The agents pick up the new rules within seconds. Total time: under a minute.

Pausing the agents entirely. Something is off — the moderator wants to take the room manually for a few minutes. They flip the dial on every agent to Off. The agents stop acting; the moderator handles everything by hand. They flip back to Assist or Auto when ready. Total time: two clicks.

The pattern across all of these: override is a single action, fast, and visible. It's not buried in a settings menu. It's not gated behind admin permissions. It's the moderator's primary interface during the event, and the agents are designed to make those overrides easy to perform and easy to learn from.

Why we built it this way

There's a deeper argument hiding behind the design, and it's worth surfacing.

The temptation when building autonomous agents is to make the autonomous case the primary path and the human-in-the-loop case the exception. The system is built around the agents acting on their own; human intervention becomes an interruption that the system has to recover from.

We built ReactLive the opposite way. The human-in-the-loop case is the primary path. Agents acting autonomously is what happens when the human has explicitly delegated that authority — via the dial, via SOUL.md, via the configuration of the event. The human is the default decision-maker; the agents borrow authority from the human, and only inside the bounds the human has set.

This sounds like a philosophical distinction. It's actually a structural one. It changes how the override system is built (override is fast and primary, not slow and exceptional). It changes how the dial is framed (the dial controls how much authority you've delegated, not how much the AI is allowed to do). It changes how the audit logs are built (every agent action is justified by the human-set rule that authorised it, not by the agent's own judgment).

The result is a system where Auto isn't scary, because Auto isn't unsupervised autonomy — it's delegated authority within explicit limits. The human is still in charge. The human has just chosen which decisions don't need their direct attention this time.

What this changes about how hosts adopt AI

There's a practical consequence to all of this, and it's worth naming.

Hosts who understand that the Orchestrator doesn't outrank them adopt the dial much faster than hosts who don't.

The host who thinks "Auto means the AI is in charge" never moves past Suggest. They keep the agents in recommend-only mode forever, because the alternative feels like surrendering authority. The host who understands "Auto means I've delegated this specific decision under these specific rules, and I can take it back at any time" climbs the dial confidently. They start at Suggest, move to Assist, then to Auto, agent by agent, as they get comfortable with the rules they've set.

That second host is the one who gets the full value of ReactLive. The first host is running an expensive Q&A platform with a transcript.

The framing matters. Outranking is the wrong frame. Delegation is the right one. The moderator delegates routine work to agents the same way an executive delegates routine work to a deputy — with explicit scope, clear escalation rules, and the right to take any decision back at any moment. The deputy is helpful precisely because they handle the work the executive doesn't need to do; the executive remains in charge by virtue of the delegation, not in spite of it.

Hosts who internalise that frame use ReactLive the way it's built to be used. The agents handle the routine. The humans handle the meaningful. The dial controls where that line falls, on this event, with this audience, this time.

What "in charge" actually requires

The last piece of this worth being explicit about: being in charge is not the same as making every decision.

A moderator who is approving every block, reading every answer, reviewing every poll suggestion is not actually in charge of the event. They're a queue worker. They're so deep in routine decisions that they don't have attention left for the decisions that actually need a human — the politically sensitive question, the speaker who needs help recovering from a misstep, the moment the room shifts.

Being in charge means having attention available for the calls that matter. The agent system is what makes that attention available. By handling the routine — the obvious spam, the repeat questions, the standard polls — the agents free the moderator to do the part of the job that only a human can do.

That's the whole architecture. The Orchestrator runs the agents. The agents handle the routine. The moderator handles the meaningful. Every part of the system is designed to make the human more powerful, not less.

The Orchestrator doesn't outrank your moderator. It works for them.

Next up: What happens when you turn all the agents off. Why ReactLive without AI is still a great event platform — and why that matters for organisations that aren't ready to flip the dial yet.

Join the waitlist to get early access. Three free events. Locked-in pricing.