AI Agents & Tools

OrcFlows has AI built into the workflow engine, not bolted on as a separate product. The agent node runs a full ReAct (reason + act) loop — powered by the Eino agent framework — as a single durable Temporal activity, with access to dozens of tools, persistent memory, your knowledge bases, and any other connector.

The Agent node

{
  "id": "research_agent",
  "type": "agent",
  "config": {
    "provider": "anthropic",
    "model": "claude-sonnet-4-6",
    "api_key": "{{ secret.ANTHROPIC_API_KEY }}",
    "system": "You are a research assistant. Always cite sources.",
    "prompt": "Research recent news about {{trigger.body.topic}} and write a 3-paragraph brief.",
    "max_turns": 15,
    "temperature": 0.3,
    "builtin_tools": ["web_search", "kb_search", "current_datetime"],
    "tools": [
      { "name": "slack", "_node_type": "tool-slack", "oauth_connection_id": "{{ connection.slack }}", "actions": ["slack_send_message"] }
    ],
    "memory_mode": "session",
    "memory_session_id": "{{trigger.body.user_id}}",
    "memory_window": 20
  }
}

Field	Description
`provider`	`anthropic`, `openai`, or `nvidia` (NVIDIA NIM, OpenAI-compatible).
`model`	Model ID, e.g. `claude-sonnet-4-6`, `gpt-4o`, or any NIM model.
`api_key`	Usually `{{ secret.* }}` — see Secrets & Credentials.
`system` / `prompt`	System prompt and the (expression-resolved) user prompt for this run.
`max_turns`	Maximum reasoning/tool-call iterations before giving up (default 15).
`temperature`	Sampling temperature; omit for the provider default.
`builtin_tools`	Names of platform tools to enable (see below).
`tools`	Connector-backed tool definitions — see Connector tools below.
`skills`	IDs of Skills to expose with progressive disclosure (name + description only, until called).
`memory_mode`	`none` (default) or `session` — see Memory.

The agent's final answer, full reasoning trace, and token/cost accounting are returned in the step output (text, cost_usd, input_tokens, output_tokens) — visible per-step in the execution detail view.

Built-in tools

Set in builtin_tools:

Tool	What it does
`web_search` / `search`	General web search via the bundled SearXNG instance — no API key needed.
`brave_search`	Brave Search API (requires a Brave API key secret).
`tavily_search`	Tavily's LLM-optimized search API.
`browser` / `browser_automation`	Headless Chromium via Playwright (CDP) — navigate pages, click, extract content, screenshot.
`kb_search`	Semantic search over a configured Knowledge Base.
`terminal`	Run shell commands in the sandboxed Docker container (Sandbox).
`read_file` / `write_file` / `list_files`	Read/write files in the execution's workspace.
`git`	Run git commands in the sandbox (clone, commit, diff, etc.).
`current_datetime`	Returns the current date/time — handy for prompts needing "today".
`github`, `jira`, `gmail`, `google_sheets`, `google_calendar`	Direct shortcuts to common connector actions, pre-wired with OAuth credentials.

Connector tools

Beyond the built-ins, an agent can call any of the 66 built-in connectors (GitHub, Slack, Stripe, databases, ad platforms, etc.) by listing them under tools. Each entry is an object, not just a name:

"tools": [
  {
    "name": "github",
    "_node_type": "tool-github",
    "token": "{{ secret.GITHUB_TOKEN }}",
    "actions": ["github_create_issue", "github_list_repos"]
  },
  {
    "name": "stripe",
    "_node_type": "tool-stripe",
    "api_key": "{{ secret.STRIPE_SECRET_KEY }}",
    "actions": ["stripe_create_refund"]
  }
]

Field	Description
`name`	Required, non-empty label for the tool entry (any string).
`_node_type`	The connector identifier from the Connector Reference, e.g. `tool-github`, `tool-slack`, `tool-sql`. Both the bare (`github`) and `tool-`-prefixed form work.
`actions`	Optional array of specific tool names to expose (e.g. `github_create_issue`). Each connector exposes several named tools — see its reference page for the full list. If omitted, or if none of the names match, every tool the connector provides is exposed.
`oauth_connection_id`	For OAuth-based connectors (Google, Slack, Notion, ...), the tenant's OAuth connection ID. Resolved to a live access token at execution time and made available to the connector as both `access_token` and `token`.
(connector-specific fields)	Any other string field (e.g. `token`, `api_key`, `base_url`, `kubeconfig`) is passed through as a credential — see each connector's reference page for what it expects.

Each connector's tool functions return a string (often human-readable text, sometimes JSON-encoded) that is fed directly back to the LLM as the tool result. See the Connector Reference for every connector's tools, parameters, and required credentials.

Memory

Set memory_mode: "session" to give an agent persistent, per-session conversation memory backed by Postgres (agent_memories table):

memory_session_id identifies the conversation (e.g. a chat user ID, phone number, or Slack thread ID) — defaults to a value derived from the execution context if omitted.
memory_window controls how many past turns (default 20) are loaded and prepended to the system prompt as a transcript.
After each run, both the user prompt and the agent's reply are saved, so the next invocation with the same memory_session_id continues the conversation.

This is what powers chat deployments and conversational voice agents.

Condition Agent

The condition_agent node (type: "condition_agent") uses an LLM to make a branching decision in natural-language terms — e.g. "classify this support ticket as billing, technical, or other" — and exposes true/false (or named) branches for branch_deps, just like the Condition node.

Multi-agent Orchestrator

The orchestrator node (type: "orchestrator") runs a supervisor + specialist team pattern for complex tasks (e.g. software engineering):

{
  "type": "orchestrator",
  "config": {
    "task": "Build a REST API for user management in Go",
    "provider": "anthropic",
    "model": "claude-sonnet-4-6",
    "api_key": "{{ secret.ANTHROPIC_API_KEY }}",
    "team": ["architect", "developer", "reviewer", "tester"],
    "max_rounds": 3
  }
}

The default team:

Architect — breaks the task into subtasks and defines the tech stack/structure.
Developer — implements each subtask in the sandbox.
Reviewer — reviews the code for correctness and quality.
Tester — runs tests and reports results.

The supervisor iterates max_rounds times between workers and reviewers before producing a final report. This is the foundation for engineering-team-style automations (e.g. "open a PR that fixes this bug").

RAG: Query Knowledge Base

The query-kb node and the kb_search agent tool both perform semantic search over a Knowledge Base, returning the top-matching chunks with similarity scores — use them to ground LLM/agent responses in your own documents.

Vision & multimodal

The vision node and document node's vision_analyze action send images/PDFs to a multimodal model (Claude or GPT-4o) for analysis — useful for OCR fallback, chart reading, and image classification steps.

The Agent node​

Built-in tools​

Connector tools​

Memory​

Condition Agent​

Multi-agent Orchestrator​

RAG: Query Knowledge Base​

Vision & multimodal​

Next​