Autonomous Agent

The Autonomous Agent is an AI node that you give a goal to — then it figures out the rest at runtime. Instead of wiring every step by hand, you describe what the agent should do and give it a set of skills (APIs to call, code to run, knowledge to search). The agent reads the conversation, decides which skills to use and when, replies to the user, and can route the flow to a different node when a condition you defined is met.

Autonomous Agent vs. other AI nodes

A regular AI Response or AI Retrieval node runs one deterministic step and moves on. The Autonomous Agent is agentic — it runs a reasoning loop, can call multiple tools across several turns, and decides for itself when it's done or when to hand the conversation off.

Add the node to your flow

1. Drop the node onto the canvas:
   • In the Flow section of Chatbot Studio, open the AI group in the tools panel and drag Autonomous Agent onto the canvas. Connect it like any other node — an input handle on the left, an output handle on the right.
2. Write the instructions:
   • Click the node to open its panel and tell the agent what its job is. This is the only required field.
3. Add skills:
   • Use + Add Skill (or the Agent Skills panel that appears when the node is selected) to give the agent API endpoints, code functions, exit scenarios, and rich-message permissions.

Settings

The Settings tab controls the agent's core behavior.

Instructions (required)

Describe the agent's job in plain language — for example, "Help the user with their support question. Look up their order status if needed." This is the agent's primary directive.

You can use flow variables here:

• Read a variable with {{FLOW.variableName}}.
• Store into a variable by mentioning its plain name (e.g. order_id) — the agent sets it when the value comes up in the conversation.

First message (optional)

Controls the agent's opening message. Switch between two modes:

• AI (default): the agent writes its own opener, guided by any text you provide (e.g. "greet and list what you can help with").
• Manual: you write the exact opening message (e.g. "Hi! 👋 How can I help?").

Tools

Built-in capabilities the agent can use. The agent decides when to use them.

Settings

Skills

Skills are the tools you give the agent. They're configured inside the node and called automatically based on the conversation. There are four skill types.

API Skills

Declare REST endpoints the agent can call. Add a Skill label (e.g. "Product APIs") to group them, then add one or more endpoints.

For each endpoint:

• Tool name — the unique identifier the agent uses (no spaces).
• Description — explains what it does and when to call it. The agent reads this to decide whether to use the endpoint, so be specific (e.g. "Search products by keyword. Use when the user asks about products.").
• Endpoint — the HTTP method (GET, POST, PUT, DELETE, PATCH) and the URL.
• Headers — static values like API keys or auth tokens. These are set at build time, not from the conversation.
• Parameters — slots the agent fills from the conversation at runtime. Give each a name and a description (e.g. a query parameter described as "search keyword").

You can also use Import cURL to paste a curl command — the URL, method, and headers are imported as-is, and the body/query fields become parameters the agent fills.

Use the Test API button to run the endpoint with sample parameter values and inspect the response before going live.

Code Skills

Write JavaScript functions the agent can run — useful for calculations, formatting, or conditional logic. Add a Skill label (e.g. "Calculation Tools"), then add one or more functions.

For each function:

• Function name — the unique identifier the agent uses (no spaces).
• Description — what it does and when to call it.
• Parameters — inputs the agent provides, available in your code as params.name.
• JavaScript code — your logic. Whatever you return is sent back to the agent as the tool result.

// params object is injected automatically by the agent
// Example: if you declared a param "n", access it as params.n
// Return a value — the agent sees it as the tool result

return params.n * 2;

Exit Scenarios

Exit Scenarios let the agent stop and route the conversation to a different node when a condition is met. There's one Exit Scenarios skill per agent, and it can hold several scenarios.

For each scenario:

• Condition — a plain-language description of when the agent should exit (e.g. "User wants a refund" or "User explicitly asks to speak to a human"). The agent evaluates this on every turn.
• Exit reply (optional) — a message the agent sends just before it exits (e.g. "Let me connect you with the right team…").
• Routing handle — each scenario gets its own output handle on the node. Wire it to wherever that path should go, such as a human-handoff or refund flow.

Rich Messages

Control which media types the agent is allowed to send mid-conversation. There's one Rich Messages skill per agent, and all types are on by default.

How the agent runs

When the flow reaches the node, the agent:

1. Reads your instructions and the last Previous Chat Count messages for context.
2. Decides whether it can answer directly or needs a tool. If it needs one, it fills in the parameters from the conversation and calls the matching API or code skill.
3. Reviews the result and loops again — up to Max Iterations times — calling more tools or replying to the user.
4. Checks your exit conditions each turn. If one matches, it sends the optional exit reply and routes the flow to that scenario's connected node.
5. Otherwise, when it's done it continues to the node connected to the agent's normal output.

Any variables the agent collects are saved to the flow (when Save as flow variables is on) and can be used downstream with {{FLOW.variableName}}.

Use cases

• Customer support — answer questions from your knowledge base, look up orders via an API, and hand off to a human on a refund request.
• Lead qualification — ask questions, store answers as flow variables, and branch based on the outcome.
• Multi-step lookups — chain several API calls (e.g. find a customer, then fetch their subscription) without wiring each step by hand.
• Calculations & formatting — run code skills to compute totals, validate input, or transform data mid-conversation.

Best practices