All guides
How to Make an AI Agent Ask a Human
A practical guide to making an AI agent stop and ask a person instead of guessing: when to ask, who to ask, how to wait hours for the answer, and how to resume the job.
By Fruxon Team
November 7, 2026
7 min read
The short answer
To make an AI agent ask a human, you need four things working together. The agent has to recognize that it is out of its depth and stop. It has to route the question to the specific person who owns that decision. It has to wait, sometimes for hours, without losing the work in progress. And it has to resume with the answer and finish the job.
Most attempts get the first step right and break on the other three. The agent asks, but it asks a shared channel, or it times out after a few minutes, or it gets an answer it can no longer use because the run is gone.
This is how a good new hire already works. When a case doesn't fit the rules, they don't guess and they don't drop it in a shared inbox. They know who decides that kind of thing, they ask that person directly, they park the case while they wait, and they pick it up again when the answer comes. The rest of this guide is how to build that.
Step 1: Decide when the agent should ask
An agent should ask when guessing would be more expensive than waiting. In practice that comes down to a few situations:
- The rules don't cover the case. A refund request outside the return window, a discount nobody has approved before, a contract clause the policy doesn't mention.
- The data doesn't agree. An invoice that doesn't match the purchase order, a customer record with two addresses, a quantity that doesn't reconcile.
- The action is above a line you set. A credit over a certain amount, an email to a key account, anything that can't be undone.
- The agent isn't sure. It has an answer, but not one it would stake the outcome on.
Write the first three down as explicit conditions wherever you can. They are easier to test and easier to explain than a confidence score.
Then give the agent a way to act on them: a tool it can call, such as ask_person, that takes the question and the context. The important design choice is that the agent decides mid-run that it needs a person. You don't wire a human step into a fixed spot in a workflow ahead of time, because you can't predict every place a real case will go off the rules.
Step 2: Decide who gets asked
This is the step that's most often skipped, and it's the one that decides whether anyone answers.
The usual shortcut is to send every question to one place: a Slack channel, a ticket queue, a shared inbox. That moves the problem without solving it. A question addressed to everyone is owned by no one, so it waits until somebody happens to pick it up.
Instead, keep a small directory of people and the decisions they own:
| Person | Owns |
|---|---|
| Mike | Pricing exceptions and discounts |
| Dana | Refunds above the standard limit |
| David | Anything touching infrastructure or access |
| Priya | Supplier disputes and purchase-order mismatches |
When the agent asks, it matches the question to an area and the area to a person. Set each person's areas once, on the person, not separately inside every agent that might need them. When Dana goes on leave or Mike changes roles, you update one record and every agent routes correctly.
Step 3: Ask a question that can be answered in one reply
Send the question where the person already works (Slack, Teams, email, Telegram) rather than in a new tool they have to remember to check.
Then make the question easy to answer. A good one has:
- The case, in one or two lines: who, what, how much.
- What the agent already knows, including what it checked and found.
- The decision it needs, as one specific question.
- The options, if there are clear ones, so the reply can be a single word.
Order 4471 from Northwind: they want a refund of $640 for a delivery that arrived 9 days late. Our policy covers late deliveries up to 7 days. They've ordered monthly for two years with no previous claims. Refund in full, refund 50%, or decline?
A person can answer that from their phone in five seconds. "Customer wants a refund, please advise" means they have to open three systems first, so it waits.
Step 4: Wait without losing the work
People answer in minutes when they're at their desk and in hours when they're not. Your agent has to treat both as normal.
That rules out the simplest approach, which is keeping the program running and polling for a reply. It ties up resources, and anything that restarts the process (a deploy, a crash, a scaling event) loses the run and the context with it.
A wait that holds up in production has these properties:
- The run's state is saved, not held in memory: the conversation, the data gathered so far, and the exact point the agent stopped.
- It survives restarts. The answer can arrive after a deploy and still find the run.
- It has no short timeout. A two-hour wait is not a failure. Set a time limit for moving the question to someone else (see step 6), not for giving up.
- It shows up in your traces as a normal step, with how long it took and who was asked, so you can see where work is waiting.
Step 5: Resume and finish the job
When the reply arrives, the agent picks up where it stopped with everything it had before, plus the answer. Then it finishes the work it started: issues the refund, updates the record, sends the email. It replies on the thread the request came in on, so the customer or colleague who asked isn't left wondering.
Record the answer alongside the run: who decided, what they said, and when. That's your audit trail. Over time it also shows you which questions keep coming up, and those are candidates for new rules the agent can apply without asking.
Step 6: Plan for nobody answering
Sooner or later the person you asked is in a meeting, on a plane or asleep. If your design has no answer for that, the work just sits.
Give every question a short fallback ladder: a time limit for the first person, then the next person, then a safe default. What that default should be is a design question of its own, covered in what an AI agent should do when nobody answers.
Mistakes that make asking fail
- Asking too often. If people get ten questions a day that the agent could have answered, they stop reading them. Ask only where a guess would be costly.
- Asking a channel instead of a person. Covered in step 2. It's the most common reason questions go unanswered.
- Questions without context. Every system the person has to open to answer is a reason to answer later.
- Treating the wait as an error. A timeout that fails the whole run throws away all the work done before the question.
- Treating silence as approval. If nobody answers, the agent must never go ahead with an action that can't be undone.
How Fruxon does it
Fruxon is built around this loop. The agent decides mid-run that it needs a person, and Fruxon matches the question to a named person from a directory of who owns what. It asks them in Slack, Telegram or email, and keeps the run open for as long as the answer takes, across restarts. If nobody answers, the question moves to the next person and then to a safe default. When the reply arrives, the agent picks up where it stopped and finishes the job in your systems.
The wait is traced and costed like any other step, so you can see who was asked, how long they took and what they said.
For the wider pattern, including approval gates and when to require them, see human-in-the-loop AI.
All guides
