AI Agent

An autonomous AI agent that runs a ReAct (Reasoning + Acting) loop — it processes a required message input, calls connected tools, optionally reads conversation memory, and returns a response in OpenAI Chat Completion format.

Use AI Agent when you need an LLM to reason about inputs and dynamically decide which tools to call:

• Building a chatbot or conversational assistant
• Creating a customer support agent that searches knowledge bases and calls APIs
• Orchestrating multi-step tasks where the LLM decides the next action
• Processing unstructured data with natural language understanding

The response output follows the OpenAI Chat Completion spec. Access the agent's answer with {{ ai_agent.choices[0].message.content }}.

{
  "id": "chatcmpl-a1b2c3d4e5f6",
  "object": "chat.completion",
  "created": 1719043200,
  "model": "gpt-4o",
  "choices": [{
    "index": 0,
    "message": { "role": "assistant", "content": "The answer is..." },
    "finish_reason": "stop"
  }],
  "usage": {
    "prompt_tokens": 150,
    "completion_tokens": 42,
    "total_tokens": 192
  },
  "_tensorify": {
    "tool_calls": [
      { "name": "http_request", "status": "success", "data": {} }
    ],
    "iterations": 2
  }
}

Build a simple Q&A agent with web search:

1. Add an API Endpoint trigger with protocol: openai-chat (for SDK compatibility — see Choosing a Trigger)
2. Add an AI Agent node and connect the trigger's output to the agent's message input (required)
3. Add an HTTP Request node configured to call a search API — connect it to the agent's Tools handle
4. Add a Return node and connect the agent's response output to it
5. Set systemPrompt: "You are a research assistant. Use the search tool to find accurate information before answering."
6. Set provider and model (e.g. OpenAI / gpt-4o)

The agent receives a user question, decides whether to search, calls the HTTP Request tool if needed, and returns a grounded answer in OpenAI Chat Completion format.

Optional: connect Window Memory to the agent's Memory handle and set a sessionKey binding to scope conversation history per user.

import manual_trigger from @tensorify/manual-trigger:4.0.0
import ai_agent from @tensorify/ai-agent:1.0.0
import http_request from @tensorify/http-request:3.0.0
import return_node from @tensorify/return:3.0.0

node trigger @tensorify/manual-trigger:4.0.0 {
    mockPayload = """{"message": "What is the weather in NYC?"}"""
}

node agent @tensorify/ai-agent:1.0.0 {
    provider = "openai"
    model = "gpt-4o"
    systemPrompt = "You are a research assistant. Use the search tool to find accurate information before answering."
    maxIterations = 10
}

node search @tensorify/http-request:3.0.0 {
    method = "GET"
    url = "https://api.example.com/search"
}

node respond @tensorify/return:3.0.0 {}

trigger.payload -> agent.message
agent.tools -> search.body
agent.response -> respond.input

The agent has a control output handle On Error. Enable it via the "Error output handle" toggle at the bottom of the settings panel.

The error branch fires when the LLM API call fails after all retries — for example, invalid API key, model not found, or rate limit exhausted. Execution routes through this handle instead of response. Connect it to a Return node to send a custom error response, or to a notification action to alert your team.

When streaming is enabled, an error event is also written to the SSE stream before the branch fires.

• Message input is required: The agent will not run without a wired message input. Always connect a trigger or upstream node before deploying.
• API keys: Set the provider's API key in your team's Environment Variables (e.g. OPENAI_API_KEY). The agent reads it at runtime.
• Tool descriptions matter: The agent uses tool names and descriptions to decide which tool to call. Vague names lead to unreliable tool selection.
• Max iterations: If the agent hits maxIterations, it returns its best answer so far with finish_reason: "length". Increase the limit for complex multi-step tasks.
• Streaming requires OpenAI Chat protocol: SSE streaming works through the API Endpoint trigger with protocol: openai-chat. The Playground's Chat mode consumes this stream automatically. Manual Trigger does not support streaming.
• Tool limit: Up to 20 tool connections per agent. If you need more, use MCP Server nodes which bundle multiple tools from a single connection.
• Default session key: When no sessionKey is set and memory is connected, the agent falls back to agent_memory:{workflow_id}. All users share one conversation buffer — always set a session key in production.
• Output schema + tools/streaming: When tools are connected or streaming is enabled, outputSchema validation is skipped. The agent returns free-form text instead.

• Window Memory — conversation history with a sliding window
• Qdrant Memory — semantic search over long-term conversation history
• MCP Server — connect external tool servers
• Build an AI Agent — step-by-step guide
• Agent Memory Guide — choosing and configuring memory