External AI agent

​

How to add the node

• Click: adds a normal AI Agent node: Jelou’s own AI agent.
• Hover: opens a selector of external AI agent providers. Picking a provider adds an External AI agent node preconfigured for that provider.

​

AI Agent or external AI agent

​

Available providers

​

Provider behavior

• Amazon Bedrock Agents: if the agent asks for a return-of-control action, the node takes Needs more information. The result of that action travels to the agent on the next turn, together with the invocation identifier, and the agent continues. Only one action per turn is supported; if the agent asks for several at once, the turn fails.
• Amazon Bedrock AgentCore: in A2A mode, both 1.0 and 0.3 Agent Cards are accepted. The endpoint qualifier applies to the Agent Card and to the calls, and Jelou keeps the same runtime session identifier for the whole conversation so that turns reach the same session. In HTTP mode, if the runtime reports an error inside the response itself (error, error_type and message), the turn fails with that reason.
• Claude Managed Agents: Jelou reads the session by streaming until the agent goes idle. If the agent stops waiting for a tool result, the node takes Needs more information. If the agent runs out of retries, the turn fails and can be retried; if it reaches its budget or the model refuses to answer, it fails with no retry; if the session terminates, it fails because the agent is no longer active. A transient error that the agent itself is retrying does not cut the turn short. A pinned agent version is an integer from 1 up.
• Salesforce Agentforce: each message is interpreted by its type. Inform is text for the user. Inquire and Confirm are also delivered as text and, in one task, the node takes Needs more information. Escalate takes Hand off to an operator, SessionEnded ends the conversation, and Failure or Error fail the turn with the reason Salesforce reports, with no retry.
• LangGraph Platform: if the graph stops on an interrupt, the node takes Needs more information and your reply resumes the graph. When several interrupts are pending at once, Jelou resumes the first one by its ID. An error the graph returns inside a successful response fails the turn with its reason.
• Microsoft Copilot Studio: Jelou delivers only the bot’s activities and drops the echo of the user’s own message.
• Azure AI Foundry: if the response arrives as failed, cancelled or incomplete, or with an error even though the HTTP status is 200, the turn fails with the reason Foundry reports. A response cut short by the content filter is treated as rejected and is not retried; a rate_limit_exceeded or server_error error is retried. With the classic API, the reason comes from the run’s last_error field.

​

OpenAI Agents (beta)

1. Jelou creates a session with the saved agent and sends it the message.
2. It polls the turn until it finishes, within the turn timeout, and delivers the text of the agent’s final answer.
3. In one task, the session is deleted when it ends. In several turns, Jelou keeps the session and sends each user message as a new message in it.

• If the agent calls a function on your side, in one task the node takes Needs more information, and your result goes back to the agent as the tool result.
• If the agent asks for a computer-use approval or an environment reconnection, the turn fails as rejected with a readable message, because a chat cannot answer it.
• If the turn does not finish within the timeout, the node takes Something went wrong and Jelou tries to cancel the turn.
• OpenAI usage, spend and billing limits and policies fail the turn with no retry; an overload or a rate limit is retried.

​

Node tabs

• Connection: the connection type, the URL or the provider’s fields, the fixed headers, the Instruction sent to the agent ({{$message.text}} by default), the Data you send and the Interaction (one task or several turns).
• Authentication: the authentication type, the organization secret, the mTLS certificate and HMAC signing.
• Transform: the pre-request and post-response scripts and, depending on the provider, the shape of the request and the response.
• Advanced: the response variable, the turn timeout, the attempts and, in several turns, the session inactivity and the reset command.

​

Events and evaluation conditions

• One task: the conversation is evaluated when the agent completes the task.
• Several turns: it is evaluated when the agent ends the conversation, with every turn from the start.
• If the turn fails, nothing is evaluated.
• A node without active conditions behaves exactly as before and stores no conversation for evaluation.

​

One task or several turns

• One task: the node sends the task once, receives the answer and exits the node.
• Several turns: the node keeps the conversation going with the agent, message by message, until the agent ends it or hands it off. While the agent answers without ending the conversation, the node doesn’t take any output: it delivers the messages to the user and waits for their next message to continue with the agent.

​

Example: one task

User:   I want to know the status of my order EJ-48213
Agent:  Your order EJ-48213 is on its way and arrives tomorrow before 6:00 PM.

​

Example: several turns

User:   I want a refund for my last purchase
Agent:  Sure, to verify your refund request I need the order number.
        Could you share it?

[the node delivers the message to the user and waits for their reply]

User:   My order number is EJ-48213
Agent:  Done, I found your order EJ-48213. The $45.00 refund was approved
        and will show up in 3 to 5 business days.

​

Node outputs

• Answered → the agent’s message was already delivered; continue the flow or end it.
• Needs more information → a question node that collects the missing piece and calls the agent again.
• Hand off to an operator → your handoff node to the Inbox.
• Something went wrong → an apology message and, if it applies, a retry or a handoff to an operator.

​

The response variable

​

Authentication and organization secrets

​

Advanced options for custom HTTP

​

HMAC signing: what’s signed and how to verify it

const crypto = require("crypto");

function isValidJelouSignature(rawBody, signatureHeader, sharedSecret) {
  const expected = crypto
    .createHmac("sha256", sharedSecret)
    .update(rawBody, "utf8")
    .digest("hex");
  const a = Buffer.from(signatureHeader || "", "utf8");
  const b = Buffer.from(expected, "utf8");
  return a.length === b.length && crypto.timingSafeEqual(a, b);
}

// rawBody must be the raw body exactly as it arrived, before parsing JSON
const valid = isValidJelouSignature(rawBody, req.headers["x-jelou-signature"], SHARED_SECRET);

​

Pre-request and post-response scripts

const request = $context.get("agentRequest");

$context.set("agentRequest.body", {
  header: {
    canal: "whatsapp",
    empresa: "Banco Ejemplo",
  },
  data: request.body,
});

const response = $context.get("agentResponse");

$context.set("agentResponse.body", response.body.data);

​

Reply later (acknowledges, replies later)

• In the same response (default): the agent answers inside the same call, as before.
• Acknowledges, replies later: the agent acknowledges with any 2xx response. Jelou delivers nothing from the acknowledgement body and leaves the node waiting for the user’s next message, with the same session inactivity time. That message is forwarded to the agent within the same execution.

​

When the conversation ends

• Field that ends the conversation: the path of the field in the acknowledgement body, for example status, data.state or items[0].s (up to 200 characters).
• Values that end the conversation: 1 to 20 distinct values, separated by commas. It accepts text, integers and true or false. When the field holds one of them, the conversation ends and the flow continues through the Answered output.

​

Outputs you must connect

• Always connect the Something went wrong output: it is the one the node takes when the wait expires without the user writing. Without that connection you can’t publish the flow.
• Connect the Answered output only if you defined the field that ends the conversation. Without those fields it isn’t used.
• The Hand off to an operator output is not required.

​

Do not reply after the time limit

• With Custom HTTP, the pre-request script (Transform tab) receives agentRequest.turn with turnId, inputId, deadlineMs and expiresAt (absolute time in ISO format). Pass it in the body so your agent can see it:

const request = $context.get("agentRequest");

$context.set("agentRequest.body", { ...request.body, reply_by: request.turn.expiresAt });

• With HTTP (Jelou turn contract), the request body already carries turnId, inputId and deadlineMs. deadlineMs is the number of milliseconds the node waits from the moment it sends the request, not an absolute time: work out the limit by adding it to the time your agent receives the message.

​

Actions: the agent picks the output

• Action name: lowercase letters, numbers and underscores, up to 32 characters, no repeats.
• Field with the action name: the path in your agent’s reply that carries the name. Defaults to action.
• Field with the action’s data (optional): the path of a value you want to use in the branch. It is saved next to the name in the response variable as actionData.

{ "result": { "action": "execute_loan", "data": { "amount": 1500 } } }

• An empty or missing field is not an action: the turn continues as usual.
• A name that is not on the list fails the turn and the flow continues through Something went wrong.
• Connect every action to a node: the node shows a warning on the canvas until you do. If you remove an action, its connections are removed too.
• When the branch ends and returns to the node, the node waits for the user’s next message and forwards it to the agent in the same execution.

​

Non-text messages

• File URL
• Button or list reply
• WhatsApp Flow response
• Location

​

Signature prefix

​

OAuth2 token over mTLS

​

The Jelou turn contract

{
  "turnId": "trn_01J8A7K2M4XQ",
  "inputId": "inp_9f3c2a71",
  "conversation": { "key": "wa:593999999999", "channel": "whatsapp", "locale": "en-US" },
  "user": { "ref": "usr_8d41c0aa" },
  "input": { "parts": [{ "type": "text", "text": "I want a refund for my last purchase" }] },
  "deadlineMs": 25000,
  "trace": { "executionId": "exec_5b2e", "nodeId": "n_agent" },
  "interaction": "multi_turn"
}

{
  "status": "completed",
  "outputs": [
    { "type": "text", "text": "Sure, to verify your refund request I need the order number. Could you share it?" }
  ]
}

{
  "status": "completed",
  "outputs": [
    { "type": "text", "text": "Done, I found your order EJ-48213. The $45.00 refund was approved and will show up in 3 to 5 business days." }
  ],
  "signals": [{ "type": "conversation_ended" }]
}

​

Test connection

​

Security

• Credentials never leave your organization’s secrets. The node only stores the secret’s name; its value is never shown or saved in the flow.
• HTTPS only. Jelou doesn’t call internal or private addresses.
• Your agent’s answers go through Jelou’s same security checks as an AI Agent’s answers, before they reach the user: they’re screened like any other outbound message, with nothing extra to configure on the node.

​

Troubleshooting

​

Availability