Human-in-the-loop

TL;DR

• Human-in-the-loop is how AI agents stop and ask a human for help when they hit a decision they should not make on their own.
• Four moves define the pattern: pause autonomously, assemble context and decision choices, route to a human via the right channel, resume on response.
• The pattern is not an approval gate stapled onto an automation. It is a runtime capability the agent uses as a callable tool.
• In FlowRunner, agents invoke human-in-the-loop the way a function calls another function. The assembled context and pre-structured choices make the decision fast.

What it means

Most automation tools think about human review as a checkpoint. Build the workflow. Add an approval step. The approval step blocks until a human clicks yes or no. Every workflow run hits the same gate whether the underlying decision is hard or trivial.

Human-in-the-loop is different. It is a runtime pattern the AI agent uses on its own initiative. The agent runs as far as it can run on its own. When it hits a decision it should not make, it pauses execution, contacts a human through the channel that human actually uses, and resumes the moment the human answers.

The pattern has four specific moves:

1. Pause autonomously. The agent decides when to stop, based on what it sees. Sometimes that is a confidence threshold (the AI is below 90% sure). Sometimes it is a rule (any wire over $10,000 needs review). Sometimes it is missing data (the invoice references a vendor the system has never seen). The agent stops itself; nobody had to anticipate every case at build time.
2. Assemble the context and the decision choices. The agent does the editorial work before it ever contacts the human. It pulls the data the human will need to understand the situation, summarizes the reasoning that led to the pause, and structures the available choices so the human picks rather than composes. The handoff is a scannable case with options, not a vague “have a look at this.”
3. Route to a human via the right channel. Different decisions need different humans, and different humans live in different tools. Some respond fastest in Slack. Some answer email. Some need a phone call. The orchestration layer picks the channel based on who is being asked.
4. Resume the moment the human responds. The decision flows back into the agent’s execution. The agent continues from where it paused. Other steps in the workflow do not have to be replayed. State is preserved.

Each of those four moves is the difference between human-in-the-loop and the cheap version. Skip any one and you get something less useful.

What it is not

Human-in-the-loop is not an approval gate. Approval gates are static checkpoints in a workflow. Every run hits the same gate. The human sees a name and a yes/no button. They have no context for the decision they are being asked to make.

Human-in-the-loop is not Slack-based confirmation. Routing a “click yes to continue” message into Slack is a delivery mechanism. The hard parts are deciding when to pause and what context to send.

Human-in-the-loop is not the ML training term. In machine learning, “human in the loop” refers to humans labeling training data or correcting model outputs to improve future performance. In production workflows, human-in-the-loop is a runtime pattern for handling decisions the AI should not make autonomously. The terms share a name and almost nothing else.

Human-in-the-loop is not the same as keeping a person in charge. Plenty of companies keep humans in charge of everything by refusing to automate. That is just manual work. Human-in-the-loop means automating what can be automated and routing only the judgment to humans.

How FlowRunner implements it

In FlowRunner, human-in-the-loop is a first-class capability AI agents invoke as a callable tool. The agent decides at runtime that it has hit a decision it should not make alone. It calls the human-in-the-loop tool. The platform handles routing, context delivery, response capture, and resumption.

A few specifics that matter:

• Channel routing. The platform supports email, Slack, WhatsApp, and phone as decision channels. The agent or the workflow designer specifies which to use for which kind of decision.
• Context delivery. The platform delivers a complete, scannable case to the human: the data, the reasoning that led to the pause, the options available, the cost of being wrong. The human can decide in seconds rather than reverse-engineering the situation.
• Subflows as callable tools. A complex human review can itself be a subflow that the agent invokes. The subflow can include conditional routing (different humans for different conditions), escalation rules (auto-escalate if no response in 15 minutes), and structured response capture.
• State preservation. The agent’s execution state is preserved across the pause. When the human responds, the agent resumes exactly where it stopped, with the human’s decision available as input to the next step.

The pattern composes. An agent can invoke a human-in-the-loop step. The step can invoke another agent. That agent can invoke another human. The orchestration layer tracks the whole chain and produces a single audit trail.

Where the term comes from

The phrase “human in the loop” originated in control systems and military command, then spread to machine learning. Both of those uses describe humans positioned somewhere inside a system’s feedback cycle.

FlowRunner uses the term in its production workflow sense: AI agents executing automated work pausing for human judgment at the points that need it. A prospect in one of our calls described what they wanted as a digital andon cord, which is the same idea in different language. We use both terms.

The pattern is the differentiator. The category we are defining, Orchestration as a Service, treats human-in-the-loop as a core platform capability rather than a feature. The work AI handles is the work AI should handle. The work humans handle is the work humans should handle. The platform routes between them.

Human-in-the-loop covers the request-response moments. The related capability for ongoing dialogue with a running workflow is Flow conversation. HITL is what an agent invokes when it needs a decision before it can continue. Flow conversation is what a human invokes when they want to check on, instruct, or steer a workflow that has not stopped.