Build agentic flows in Agent Studio

Access Agent Studio

Agent Studio lives inside AI-focused tooling in ACEIRT™ Fusion and provides the visual canvas for agentic flows.

Understand the canvas model

Agent Studio uses a node-based canvas. Every runnable flow connects from a Start node through one or more agent nodes to an End node.

• Start node: Entry point for the flow and any input variables.
• Agent nodes: The work steps, either sequential actions or AI agents with tools.
• End node: Marks completion and final output.

A valid flow meets two rules:

• Every path starting at Start must eventually reach End.
• Every agent node must be reachable from Start and lead toward End (no isolated or dead-end nodes in published flows).

A simple sequential flow might look like:

When you add new nodes, always connect them with edges so that there is a continuous path from Start to End for all branches.

Work with variables

Agent Studio uses variables to pass data between nodes and control behavior. Variables fall into three main types.

• Global variables: Configuration or settings shared across runs.
• Input variables: Values that come into the flow when it starts.
• Runtime variables: Values computed or captured while the flow runs.

Variable types at a glance

Global variables

Global variables store configuration that rarely changes per run.

Examples:

• A global default_model string used by multiple AI nodes.
• A global support_hours text used in messaging across flows.

Define global variables when you want to avoid repeating the same configuration in many places.

Input variables

Input variables capture data passed into the flow when it starts, from a UI, integration, or API call.

Examples:

• user_question from an Ask AI text field.
• lead_email from a form in a funnel or page.

Map these variables in the Start node so downstream nodes can reference them in prompts, conditions, or API calls.

Runtime variables

Runtime variables hold values produced while the flow executes.

Examples:

• qualification_score set by an AI agent that rates a lead.
• api_status and api_payload from an API call node.
• user_preference collected from a single-choice collection node.

Use runtime variables for branching, reusing outputs, and building more complex logic as the flow progresses.

Choose node types

Agent nodes perform the work in your flow. You typically choose between a Sequential agent (explicit step-by-step nodes) and an AI agent (LLM-driven orchestration with tools).

Add collections for user input

Collections nodes let the flow ask users for information and store it as variables.

Collections can capture:

• Email: For follow-ups or lead capture.
• Phone: For SMS or call workflows.
• Single-choice buttons: For quick preferences or routing decisions (for example, "Sales", "Support").
• Text with min/max length: For constrained answers like short descriptions or detailed questions.

Map each collection field to a runtime variable. Downstream nodes can then use that variable in prompts, API calls, or conditions.

Use branching and conditions

Branching lets a flow follow different paths based on runtime variables. This is how you build more adaptive and personalized behavior.

Common patterns:

• Route leads by qualification_score (for example, greater than 80 goes to high-priority path).
• Choose between knowledge base and web search depending on a topic_category variable set by an AI agent.
• Send users to different sequences based on a user_intent label like "support", "sales", or "billing".

To add branching:

• Configure a condition node or condition section on an existing node.
• Reference runtime variables and define rules (for example, equals, contains, greater than).
• Connect each condition outcome to the next appropriate node, and ensure all paths eventually rejoin or reach the End node.

Branching logic is evaluated at runtime, so updating conditions can change behavior without rebuilding the entire flow.

Test and publish your agent

Use test mode to validate flows before making them available to real users or systems.

Deploy and connect your agent

After you publish, you can connect the agentic flow to other parts of ACEIRT™ Fusion or external systems.

• Execute via API: Trigger the agent from your own applications or integrations by sending inputs that map to the flow's input variables and reading outputs and runtime variables in the response.
• Use inside Ask AI: Configure Ask AI in ACEIRT™ Fusion to route certain queries into your published agent flow so end users or teammates benefit from its logic and tools.

Keep deployment setups aligned with how you defined input and output variables in the Start and End nodes so behavior remains predictable.

Common patterns

These patterns show how to combine nodes, variables, and branching in Agent Studio.

• Lead qualification

  • Start with input variables like lead_email and lead_message.
  • Use an AI agent node with tools (knowledge base or MCP) to analyze fit and produce a qualification_score runtime variable.
  • Branch by score to different follow-up sequences or assign priority labels.

• Content generator

  • Accept topic, audience, and tone as input variables or via collection nodes.
  • Use a text generation node or AI agent to draft content and store it in a runtime variable.
  • Optionally pass this variable to image, audio, or video generation nodes to create supporting media assets.

• Support triage

  • Capture a user_question and category_choice via collections.
  • Run an AI agent with knowledge base and web search tools to classify intent and propose answers.
  • Branch to different paths (for example, self-service response, escalation summary, or handoff) based on runtime variables like intent_label and urgency_level.

What’s next

Deepen your Agent Studio work with related AI Studio capabilities.