> ## Documentation Index
> Fetch the complete documentation index at: https://docs.cogniagent.ai/llms.txt
> Use this file to discover all available pages before exploring further.

# Human Step

> Bring a real person into a workflow over their own channel, then continue on the branch that matches what they did.

The Human Step node brings a real person into your workflow. It sends them a message on a channel they already use (email through Gmail or Outlook, Slack, Microsoft Teams, or SMS), waits for their reply, and then continues your workflow on the branch that matches what they did.

<Frame caption="A short tour of the Human Step node, from a paused workflow to a decision and back.">
  <video controls className="w-full aspect-video rounded-xl" poster="/images/nodes/human-step-video-poster.jpg" src="https://mintcdn.com/glorium/8p2xjAgjIddNPOUM/videos/human-step.mp4?fit=max&auto=format&n=8p2xjAgjIddNPOUM&q=85&s=3a96a9b95be03f443312f320f6c4ba8f" data-path="videos/human-step.mp4" />
</Frame>

Your AI writes the message with the context the moment needs, the person replies in plain words, and the workflow resumes on its own. There is no new app to learn and no approvals queue to check. The work reaches the right person, then keeps moving.

## When to use

* **Get a sign-off before a risky action** - "Approve this refund before we issue it?"
* **Keep someone in the loop** - Let a manager know a deal closed, then carry on without waiting.
* **Collect details a workflow needs** - Ask the person for a shipping date, a budget number, or a contact email.
* **Let someone choose** - Offer a short list of options and route on the one they pick.
* **Ask for a review** - Show a draft and capture a thumbs-up plus any comments.
* **Confirm an action** - Have the person acknowledge before the workflow moves on.

## How it works

1. Pick the **pattern** that matches what you need the person to do (the six patterns are described below).
2. Pick the **channel** to reach them on. For everything except Notify, the channel must be one the person can reply on (email, Slack, Teams, or SMS).
3. Enter **who to reach**: their email address, Slack handle, Teams account, or phone number. You can use `{{}}` to pull this from an earlier step, for example `{{manager.email}}`.
4. Write the **message** they will see. Use `{{}}` to drop in details from earlier steps, for example `Approve the ${{order.amount}} refund for {{order.customer}}?`
5. The workflow **pauses** and waits. When the person replies, the workflow continues on the branch that matches their answer.

<Note>
  The wait can last days. The workflow stays paused, sends gentle reminders if the person goes quiet, and picks up exactly where it left off once they reply.
</Note>

## The six patterns

Each pattern shapes the message the person sees and the branches the node produces.

<AccordionGroup>
  <Accordion title="Approval" icon="circle-check">
    Ask the person to approve or reject. The workflow branches on their decision. You can optionally ask for a brief reason when they reject.
  </Accordion>

  <Accordion title="Notify" icon="bell">
    Send a one-way message and continue right away. Notify never waits for a reply, so use it only when you do not need an answer.
  </Accordion>

  <Accordion title="Collect info" icon="list-check">
    Ask for one or more pieces of information, one question at a time. Each field has a type, such as text, number, email, date, phone, or a choice from a list.
  </Accordion>

  <Accordion title="Select" icon="square-check">
    Ask the person to pick from a set of options. You can allow a single pick or several.
  </Accordion>

  <Accordion title="Review" icon="thumbs-up">
    Show the person something to look over and capture their feedback, with room for optional comments.
  </Accordion>

  <Accordion title="Confirm" icon="check-double">
    Ask the person to acknowledge a message before the workflow continues.
  </Accordion>
</AccordionGroup>

## Outcome branches

When you wire the node, you connect each outcome to whatever should run next. The outcomes you get depend on the pattern:

| Outcome   | When it fires                                                         | Patterns                              |
| --------- | --------------------------------------------------------------------- | ------------------------------------- |
| Approved  | The person approved                                                   | Approval                              |
| Rejected  | The person rejected (with an optional reason)                         | Approval                              |
| Completed | The person responded successfully                                     | Collect info, Select, Review, Confirm |
| Sent      | The message was sent (fires right away)                               | Notify                                |
| Failed    | The person did not respond in time, or the information was incomplete | All except Notify                     |

The Failed branch also tells you why it failed. The reason is either **No Response** (the person never replied) or **Incomplete** (a required answer was missing).

<Tip>
  You do not have to connect every branch. If a branch has nowhere to go, that path simply ends.
</Tip>

## Reminders

If the person goes quiet, the step sends gentle automatic reminders before giving up. You decide how many reminders to send and how far apart.

<Note>
  After the last reminder with still no reply, the step ends on the **Failed** branch with the reason **No Response**. Turning reminders off (setting them to zero) makes the step wait indefinitely: no reminders, and no automatic failure.
</Note>

## Questions during the step

You can give the assistant background about the task, plus knowledge bases to draw from, so the person can ask clarifying questions in the middle of the conversation and get answers.

<Note>
  This context is reference material only. The assistant uses it to answer the person's questions, never to fill in the person's own answer for them.
</Note>

## Example: refund approval

A common use is approving a refund before issuing it:

<Steps>
  <Step title="Choose the pattern and channel">
    Pick the **Approval** pattern and send it over email.
  </Step>

  <Step title="Address it and write the message">
    Send it to `{{manager.email}}` with the message: `Approve the ${{order.amount}} refund for {{order.customer}}?`
  </Step>

  <Step title="Wire the branches">
    * **Approved** - Issue the refund.
    * **Rejected** - Log the reason using `{{human_step_1.comment}}` and notify the customer.
    * **Failed** - Escalate to a supervisor when no one replies in time.
  </Step>
</Steps>

## Settings

<ParamField path="pattern" type="string" required>
  What you need the person to do: **Approval**, **Notify**, **Collect info**, **Select**, **Review**, or **Confirm**.
</ParamField>

<ParamField path="channel" type="string" required>
  The channel to reach the person on (Gmail, Outlook, Slack, Microsoft Teams, or SMS). For every pattern except Notify, pick a channel the person can reply on.
</ParamField>

<ParamField path="recipient" type="string" required>
  Who to reach: an email address, Slack handle, Teams account, or phone number. Supports `{{}}` to pull the value from an earlier step.
</ParamField>

<ParamField path="message" type="string">
  The message the person sees. Supports `{{}}` to insert details from earlier steps. For Collect info, this is an optional lead-in before the questions.
</ParamField>

<ParamField path="reminders" type="number" default="3">
  How many automatic reminders to send if the person goes quiet, and how far apart. Set to zero to wait indefinitely with no reminders.
</ParamField>

<ParamField path="context and knowledge" type="object">
  Optional background about the task plus knowledge bases, so the person can ask clarifying questions during the step. Used only to answer questions, never to fill in their answer.
</ParamField>

## Outputs

Read these in later steps using `{{human_step_1.<field>}}`. Some fields appear only for certain patterns.

<ParamField path="outcome" type="string">
  The branch that fired: Approved, Rejected, Completed, Sent, or Failed.
</ParamField>

<ParamField path="failedReason" type="string">
  On the Failed branch only: either "No Response" or "Incomplete".
</ParamField>

<ParamField path="responder" type="string">
  Who responded (name or identifier).
</ParamField>

<ParamField path="started_at" type="string">
  When the step began the interaction.
</ParamField>

<ParamField path="responded_at" type="string">
  When the person last replied.
</ParamField>

<ParamField path="ended_at" type="string">
  When the interaction ended.
</ParamField>

<ParamField path="attempts_made" type="number">
  How many reminders were sent.
</ParamField>

<ParamField path="transcript" type="array">
  The full back-and-forth of the conversation.
</ParamField>

<ParamField path="decision" type="string">
  Approval only: "Approved" or "Rejected".
</ParamField>

<ParamField path="comment" type="string">
  Approval only: the reason the person gave when rejecting, if any.
</ParamField>

<ParamField path="collected" type="object">
  Collect info only: the answers, as a bundle of field name and value.
</ParamField>

<ParamField path="fields_captured" type="array">
  Collect info only: the fields that were answered.
</ParamField>

<ParamField path="fields_missing" type="array">
  Collect info only: the required fields that are still missing.
</ParamField>

<ParamField path="selected" type="string">
  Select only: the option or options the person chose.
</ParamField>

<ParamField path="comments" type="string">
  Review only: the reviewer's feedback (may be empty).
</ParamField>

<ParamField path="acknowledged" type="boolean">
  Confirm only: true once the person acknowledges.
</ParamField>

## Next steps

<CardGroup cols={2}>
  <Card title="Channels" icon="share-nodes" href="/features/channels">
    Set up the email, Slack, Teams, or SMS channel the message is sent on.
  </Card>

  <Card title="Conversation Flow" icon="comments" href="/nodes/communication/conversation-flow">
    Embed a richer, multi-turn conversation when one question is not enough.
  </Card>
</CardGroup>
