Flow designerAbout nodes

Configure the end node

The End Call Node is the final stop in your flow—literally the “hang up” or “session terminate” command for your AI agent. Once the AI agent reaches this node, it will deliver any last scripted message, perform any final cleanup actions you’ve attached, and then close out the conversation immediately. There is no outgoing node: the flow terminates here.

1. Purpose & When to Use

  • Final Closure: Use the End Call Node whenever you want to explicitly signal to the AI that the dialogue is over. This could be after:

    • A successful resolution (e.g., “Your issue is resolved—thank you for calling!”)

    • A user‐requested exit (e.g., “No thanks, that’s all I needed.”)
      An unrecoverable error or fallback (e.g., “I’m sorry, we cannot process your request. Goodbye.”)

  • No Further Interaction: Once the AI sends its final line, the conversation session ends. The user cannot reply to an End Call Node and expect the flow to continue.

  • Optional Cleanup: If you have any backend tasks—like logging the session as closed, notifying another system that the call ended, or archiving chat history—you can attach those as Custom Actions here. The engine runs them before terminating.

2. End Call Node Fields & Configuration

  1. Instructions

    • What It Is: A text box where you write exactly what you want the AI to say as its final statement.

    • Structure & Tone:

      • Concise & Clear: Since this is the last thing your user hears, keep it short but polite. “Thanks for calling. Have a great day, goodbye!” is better than a multi‐paragraph speech.
  1. Single‐Message Only: The agent will send exactly what you put here (no multi‐turn). If you need to embed dynamic data (like the user’s name), use {} placeholders exactly as you would in a Step Node: e.g.,

  1. Variables (Optional)

    • What They Are: Any dynamic placeholders you reference in your final message—e.g., {first_name}, {ticket_id}, {refund_amount}.

    • Why It Matters: If you reference {ticket_number} in your closing script, you must declare it here so the engine can substitute the correct value. Otherwise, you’ll get a runtime error (or see “{ticket_number}” literally in the message).

3. Flow Termination Behavior

  1. Deliver Final Message

    • As soon as the flow engine arrives at the End Call Node (via a Step, Branch, or Jump), it processes any attached Custom Actions first.

    • After actions complete (or if there are none), the AI sends exactly the text you put in Instructions.

  2. Terminate Session

    • Immediately after sending that last line, the engine closes the conversation.

    • No outgoing arrows or nodes exist—this is the hard stop. Any user input after this point is ignored (or logged as a new session, depending on backend design).

4. Best Practices & Tips

  1. Think Through the User Experience

    • No “Dangling Questions”: Don’t ask “Anything else?” here—there is no “else” once the call ends. End Call Node is not a place for contingency.

    • Clarity over Applause: Your user shouldn’t be left wondering if the script is still listening. Make it obvious: “This concludes our chat—goodbye!”

  2. Use It Sparingly

    • Single Terminus: If you have multiple “end” scenarios, create a single, well‐named End Call Node (e.g., “End Call – Standard”) and adjust its Instructions dynamically with variables. Then, from other spots, Jump or route to that single node—rather than duplicating multiple end messages.

    • Distinct Error vs. Success Messages: If you have two different types of end messages (e.g., “Thank you; goodbye” vs. “I’m sorry; goodbye”), consider making two separate End Call Nodes: “End – Success” and “End – Error,” so that you keep tone and wording consistent.

  3. Keep Final Scripts Short

    • Avoid Information Overload: Users either hear this at the very end of a dialogue or as a fail‐safe. If you need to convey more than two sentences of info, consider splitting: send a shorter closing text here, then have a final Step Node just before that to display or speak the extra details.

  4. Pair with Jump or Branch for Contextual Endings

    • Branch + End: If you have multiple end‐of‐flow reasons, you can route via a Branch Node to different End Call Nodes:

      • Branch Cond A → End Call – Success

      • Branch Cond B → End Call – No Access

      • Branch Cond C → End Call – Technical Error

    • Jump + End: If you want every “Fallback” or “Catch‐all” path in your flow to eventually land on a single “End Call – Fallback” Node, drop a Jump To right before that end.

6. When Not to Use End Call Node

  • Intermediate Content: If you still want the user to interact, don’t put them in an End Call Node. Use a Step or Conversation Node instead.

  • Partial Sessions: If you want to end or continue based on some condition, route through a Branch Node first. Only after the “end” condition should you hit End Call.

8. Summary & Takeaways

  1. End Call = Conversation Terminate: Once you arrive here, the user cannot continue. No more AI output after this node.

  2. Keep It Short & Clear: Final messages should be concise, polite, and free of dangling questions.

  3. Declare All Variables: If you use {} placeholders in your final script, list them so the AI can replace them.

  4. Attach Only Quick Actions: If you need to log or notify, keep custom actions lightweight—don’t hold up the user for lengthy operations.

  5. Use Branch or Jump To Beforehand: Decide all “should I end or not?” logic upstream. End Call Node is simply “execute final line, then hang up.”

Mastering the End Call Node ensures that every conversation concludes decisively and professionally—no hanging threads, no unspoken questions, and no user frustration from thinking the AI is still listening when it’s already gone.