AI Agent StudioAgent templates

Templates and examples for AI Studio agents

Copy-paste prompt templates and patterns for building agentic flows in ACEIRT™ Fusion AI Studio, including FAQs, content, CRM and knowledge agents.

What an agent is in ACEIRT™ Fusion AI Studio

Agent Studio in ACEIRT™ Fusion lets you design multi-step, tool-using flows on a node-based canvas instead of a single prompt-response. Every runnable flow connects from a Start node, through one or more agent and tool nodes, to an End node.

Within a flow, you orchestrate:

  • Agent nodes that decide what to do next (routing, planning, tool selection).
  • Tool nodes for knowledge bases, web search, MCP servers, API calls, and collections.
  • Generative nodes that turn structured context into text, images, or other media.
  • Variables (Global, Input, Runtime) that carry state across nodes and branches.

Use the templates below as starting points for agent instructions that pair well with these node types and variable patterns.

These templates focus on the system-level instructions you give to your agent nodes. Combine them with good node wiring, variable design, and test iterations in Agent Studio to get reliable flows.

Agent templates

Use these templates as the base system prompt for your primary agent node. Adapt field names and variable references to match your canvas (for example, {{input.prompt}}, {{kb_results}}, or {{api_response}}).

This agent turns a structured spreadsheet or table-based data source into consistent, policy-safe answers. Pair it with a knowledge base node that indexes your spreadsheet or CSV.

Goal
You are a policy and FAQ assistant for our organization.
You answer questions based ONLY on the provided spreadsheet-backed knowledge base.

Inputs
- user_question: natural language question from the user
- kb_rows: array of matching rows from the spreadsheet knowledge base
  Each row includes: section, topic, question, answer, tags, effective_date, source_url

Required outputs
- Always return a single JSON object with this exact shape:

{
  "answer": "short, direct answer in 1–3 sentences based ONLY on kb_rows",
  "supporting_points": [
    "bullet point 1 summarizing a specific row or clause",
    "bullet point 2 summarizing a specific row or clause"
  ],
  "policy_risk": "low | medium | high",
  "follow_up_questions": [
    "optional clarifying or next-step question 1",
    "optional clarifying or next-step question 2"
  ],
  "citations": [
    {
      "section": "Policy section or FAQ category",
      "topic": "Topic or row title",
      "source_url": "URL or document reference if available",
      "effective_date": "YYYY-MM-DD"
    }
  ],
  "meta": {
    "answered_from": "spreadsheet",
    "kb_rows_used": 0
  }
}

Behavior constraints
- Use ONLY information from kb_rows. If the answer is not present or is ambiguous, say you do not have enough information.
- Never invent policy details, numbers, or dates.
- If multiple rows conflict, flag policy_risk as "high" and explain the conflict briefly.
- If kb_rows is empty, set answer to a short apology and policy_risk to "high".
- Keep tone neutral, professional, and concise.
- Ask at most 2 follow-up questions and only if they materially change the answer.
- Never provide legal advice. Refer to the policy owner instead.

Test cases
1) user_question: "How many days of paid vacation do full-time employees get each year?"
2) user_question: "Can contractors access the same benefits as full-time staff?"
3) user_question: "What is our refund policy for annual subscriptions purchased more than 90 days ago?"

Start by pasting these templates into a single agent node and wiring a minimal Start → Agent → End path. Once you like the behavior, introduce tool nodes (knowledge base, API calls) and convert ad-hoc text fields into structured runtime variables.

Suggested nodes and variable patterns

Design your ACEIRT™ Fusion Agent Studio flows so that each node has a clear purpose and passes only the variables it needs. The checklist below maps common patterns to node types and variable scopes.

Core node layout

  • Start → Agent → End
    Use this as the minimal skeleton. Start collects initial Input variables, your primary agent node makes decisions, and End returns structured output.

  • Sequential agent vs. generative nodes
    Use an agent node for planning and routing, then separate generative nodes for each content artifact (email, blog, note) so you can log, reuse, and A/B test generations independently.

  • Tool nodes between agents
    Insert knowledge base, web search, MCP server, and API call nodes between agent nodes so each agent has fresh, structured context to reason about.

  • Spreadsheet-backed FAQ / policy agent

    • Start: collect user_question, optional policy_area.
    • Knowledge base: spreadsheet or table source, returning kb_rows.
    • Agent: apply the policy FAQ template using user_question and kb_rows.
    • End: return JSON answer and citations.
  • Video-to-blog publisher agent

    • Start: collect video_url, target_audience, brand_voice.
    • Web or MCP node: fetch video metadata and transcript → video_title, transcript.
    • Generative node: outline + blog copy using the video template.
    • Optional collection node: store generated posts for later reuse.
    • End: return blog JSON.
  • Multi-content generator agent

    • Start: collect campaign_brief, product_details, audience, brand_voice.
    • Agent: normalize intent and constraints, decide which assets to generate.
    • Generative nodes: one per channel (email, social, landing) using shared Input variables.
    • Collection node: aggregate outputs into a single JSON for End.
  • Knowledge-base chat responder

    • Start: collect user_question, conversation_history.
    • Knowledge base: query internal docs → kb_results.
    • Optional web search: fill web_results for gaps.
    • Agent: apply the KB responder template and decide if handoff is needed.
    • End: return structured answer and metadata.
  • CRM manager agent

    • Start: collect natural language user_intent.
    • API or MCP nodes:
      • Lookup contact and deals by email or name → current_contact, current_deals.
    • Agent: map intent to operations JSON using the CRM template.
    • API or MCP node: execute operations when confirmed.
    • End: return final state and dry_run_summary.

Variable patterns

  • Global variables

    • Brand or policy constants: brand_voice_default, policy_risk_threshold.
    • API configuration: crm_base_url, crm_auth_token (not exposed to users).
    • Guardrails: allowed_operations, unsafe_fields.
  • Input variables

    • User-facing fields from Start: user_question, video_url, campaign_brief, user_intent.
    • Channel or audience hints: target_audience, primary_channel.
  • Runtime variables

    • Tool outputs: kb_results, web_results, transcript, api_response.
    • Intermediate reasoning: normalized_intent, operations, dry_run_summary.
    • Collections: generated_assets, conversation_memory.

Structure your prompts so agent nodes read from Input and Global variables, and write decisions into Runtime variables that downstream nodes consume.

Iteration prompts to refine your agent

Use these prompts in ACEIRT™ Fusion when chatting with or editing your agent to tighten behavior:

  • "Show me where my current agent prompt might allow hallucinations and rewrite it with stricter constraints."
  • "Refactor this agent into multiple nodes: one for planning, one for knowledge retrieval decisions, and one for final answer generation."
  • "Given this example conversation, adjust the JSON schema so the End node returns exactly what my app or CRM API expects."
  • "Audit my variable usage and suggest which values should be Global, Input, and Runtime for clarity and reusability."
  • "Optimize this agent for latency by reducing unnecessary calls to knowledge base and web search nodes."
  • "Rewrite the instructions to better handle 'I do not know' cases when the knowledge base has no relevant results."
  • "Add safety rules so the CRM agent never changes billing or contract-related fields, even if the user asks."
  • "Suggest test cases that cover edge conditions for this flow, including empty tool responses, conflicting data, and ambiguous user intent."
  • "Simplify the language of this agent prompt so non-technical teammates can understand and safely edit it."
  • "Tune the agent's tone to match this brand voice guide while keeping answers concise and structured."

What’s next

Connect these templates with the rest of ACEIRT™ Fusion AI Studio to build complete experiences.