AI Agent Composer

Introduction

The AI Agent Management Panel is the central place to create, configure, deploy, test and manage AI agents in Autom Mate. Each agent is powered by a selected AI model and is automatically linked to an Autom, which defines the execution logic. After deployment, you can test your agent directly in the Playground before integrating it into a production workflow.

Agents Page

The Agents Page is the entry point for managing all of your AI agents.

List View: Displays all existing agents, showing:
- Agent Name
- Model Type (GPT-4, GPT-4o, GPT-4-turbo, o3-mini, etc.)
- Status (Active / Inactive)
- Last Updated date
Agent Actions:
- Click on an agent to view and edit its configuration.
- Delete an agent if it is no longer required (confirmation needed).
Create Agent Button: Located in the top-right corner. This button launches the agent creation form.

MSP or Multi-Tenant Usage

This screen is designed for defining the agent at the global configuration level. If your system operates in MSP Hub mode, each agent must be assigned to a specific tenant or MSP organizational space.

This assignment is performed in a separate Permissions step during creation of technician. The agent’s access scope can be restricted to the assigned tenant.

Creating an Agent

When you click Create Agent, you are taken to Agent Details page. Here, you define how the agent will operate.

Configuration Fields

Agent Name: A required field where you define the display name of the agent. This name appears in dashboards, integrations, and the AI Composer list.
Selected Model: Choose the AI model (e.g., GPT-4, GPT-4o, GPT-4-turbo, o3-mini).
- A “More info” link provides how to add your OpenAI Credentials to the system to use in Agent.
Credentials: Authentication details required for model access.
Temperature: Controls randomness in responses (lower = consistent, higher = creative).
Role Prompt: A role instruction that defines the agent’s role, tone, constraints, personality and behavior.
- The prompt editor allows Markdown-style formatting (e.g., # Role, ## Instructions, etc.).
- You can choose from predefined templates using the Prompt Preset Dropdown (e.g., Default Prompt).
- The ➕ button allows adding a new custom prompt template.

Example Prompt

### Role - Primary Function
You are an AI assistant that helps users with inquiries, issues, and requests. 
Provide clear, friendly, and efficient responses.

### Constraints
1) Do not disclose internal data or training sources.  
2) Stay on topic; politely redirect off-topic questions.  
3) Answer only within provided context; otherwise, give a fallback response.  
4) Do not perform actions outside your defined role.

Deployment

Click Deploy to activate the agent.

This action automatically creates an Autom in the background.
The Autom represents the agent’s workflow and can be accessed and modified later.

Managing the Agent's Autom

After deploying an agent, you will see the option Open Agent Autom.

Autom View

The Autom View allows you to explore and modify the underlying automation that powers your AI Agent.

Launches in a separate window for a dedicated editing experience.
Displays the Autom flow that defines your agent’s logic and execution pipeline.
Provides a visual interface to extend, modify, or debug how the agent processes inputs, integrates with data sources, or triggers actions.

💡 Tip: Be careful while using Autom View to fine-tune complex agent behaviors — such as chaining API calls, adding decision branches, or integrating advanced workflows — without affecting the main configuration. You can break the Agent logic and process.

Editing the Autom

You may add, modify, or remove steps.
Every change directly impacts how the agent responds.
Incorrect modifications may break triggers or response logic.

Always test your Autom changes in Playground before using the agent in production.

Trigger Method

By default, the Trigger Method is API. This is how the Playground communicates with your agent. If you are not integrating with another chat interface, do not change this setting. If you do change it, Playground will no longer return responses.

Playground — Real-Time Agent Testing

The Playground is the built-in test console for AI agents.

The Playground provides a real-time testing environment where you can interact with your AI Agent directly inside the Autom Mate platform. It allows users to simulate conversations, observe live streaming responses, and validate the agent’s behavior before deployment to production or external channels.

Interface Breakdown

Section

Description

Header Area

Displays the current agent name (e.g., Autom Mate Docs Agent) and last updated time. It helps you confirm which configuration is active during testing.

Tab Navigation

Located under the header. You can switch between Agent Details, Playground, Data Sources, Actions, Channels, and Logs.

Connection Status

Indicates whether the playground is connected to the AI model backend: - Connected → Agent ready for interaction. - Disconnected → Chat unavailable until reconnection. - The Reconnect (🔄) button refreshes the link.

Export Chat History (⬇️)

Downloads the full conversation log as a text file. Useful for documentation, debugging, or version comparison of prompts and outputs.

Clear All Messages (🧹)

Removes all chat content from the session window. This allows you to restart testing with a clean context without reloading the page.

Main Conversation Panel

The central area where the dialogue occurs. When no session is active, it displays the placeholder: “Start a conversation — Send a message to test your agent’s capabilities with real-time streaming responses.”

Chat Input Field

Located at the bottom of the panel. Users can type prompts (up to 4000 characters) and send them using the Send (▶) button or by pressing Enter.

Status Bar / Connection Warning

Appears below the input field (e.g., “Connection required” in red). Indicates when chat input is disabled due to disconnection or server issues.

How to Use

Connect to the Agent

Confirm the connection indicator shows Connected.
If not, click the Reconnect (🔄) button to re-establish communication.

Start a Conversation

Enter a message in the text box (e.g., “Summarize the release notes for version 5.0.0”).
Press Enter or click ▶.
The agent replies in real time using streaming output, letting you observe how it processes and constructs responses.

Manage Conversations

Use Export (⬇️) to save the conversation log locally for audits or QA.
Use Clear (🧹) to delete all messages from the view and restart a clean session.

Iterate Quickly

Adjust prompts or parameters (like temperature) from the Agent Details tab.
Return to Playground to instantly test how the new configuration behaves.

What to Check

Accuracy: Does the agent answer correctly?
Consistency: Does it follow the role prompt across multiple queries?
Latency: Are response times acceptable?
Role Adherence: Does it stay within the defined behavior and constraints?

Data Sources – Managing Agent Knowledge Inputs

The Data Sources tab enables the configuration of information sources that define an AI Agent’s knowledge base and reasoning context. Through this section, users can connect multiple data types such as uploaded documents, public websites, text entries, and integrated applications to provide the agent with structured and unstructured knowledge.

These data inputs directly influence the agent’s ability to deliver accurate, context-aware, and organization-specific responses. By enriching the agent’s accessible information, the Data Sources configuration ensures that the AI Agent can reason over domain-relevant data and generate responses aligned with business context and user intent.

Card

Description

Upload Files

Allows you to upload files as the agent’s data source.

Public Websites

Adds external website content to the agent’s knowledge base.

Applications

Enables data import from connected third-party apps.

Text

Let you enter text manually to teach or enhance the agent’s context.

At the bottom, the “All added data sources” section lists every data item added. If no data has been added, an empty state icon appears with a short prompt message. A Filters button on the right allows users to filter and search through added data sources once multiple items exist (by type, name, or source origin).

Upload Files

This option allows uploading files from the local system to enrich the agent’s knowledge. Clicking the Upload Files card opens the Upload File modal window. In the center, a drag-and-drop area is displayed with the message:

“Upload File or Drag & Drop File here”

Supported file formats are pdf, doc, docx, txt, csv, pptx, json, md.

Users can either choose a file manually using the “Choose File” button or drag and drop it directly. Once a file is selected, the Finish button becomes active.

How to Use

Click the Upload Files card.

Choose or drag-and-drop a file.

Click Finish.

The uploaded file appears in the “All added data sources” list below.

Each file automatically integrates into the AI Agent’s RAG (Retrieval-Augmented Generation) pipeline for contextual responses.

💡 Note: Unsupported file formats trigger a user-friendly error notification.

Public Websites

This feature allows the agent to learn from web-based content by adding website URLs.

Clicking the Public Websites card opens a modal titled Public Website. At the top, a URL input area labeled Crawl Website is displayed:

https:// [ Enter website URL ]

After entering a valid URL and clicking Load, the system scans the website. Detected links appear in a list below under:

“All Links (0/10 selected)”

Users can select up to 10 links to include as sources. Once selection is complete, the Finish button becomes active.

How to Use

Click Public Websites.

Enter the full URL of the site to be crawled. (e.g., docs.autommate.com)

Click Load to fetch the available pages.

Select the desired links (maximum of 10).

Click Finish to confirm.

💡 Tip: For large sites, limit your input to specific pages to avoid long crawl times and unnecessary data noise. Also, only publicly accessible pages can be indexed (no login-required domains).

Applications (Third-Party Sources)

The Applications option in the Data Sources tab allows you to connect external platforms and enterprise tools as live data sources for your AI Agent. By integrating with third-party systems such as Salesforce, ServiceNow, Jira, Xurrent, and others, your agent can fetch, query, and reason over real-time business data making responses more relevant, actionable, and context aware.

This feature turns your AI Agent from a passive responder into an active automation component within your ecosystem.

Hints

Each action defines what the agent can do inside an external system — for example, “Create Customer Request in Jira Service Management” or “Fetch Knowledge Article from Xurrent.”
Credentials and input parameters ensure every action runs securely and correctly.
Each application contains multiple actions that can be used as dynamic data endpoints.
These integrations let your agent access and retrieve structured data directly from external systems like CRMs, ITSMs, and collaboration platforms.

Interface Overview

Section

Description

Application Selector

Displays a categorized list of integrated systems such as Salesforce, ServiceNow, Xurrent, and Jira.

Action Library

Each listed app includes available actions (e.g., Get Record, List Tickets, Fetch Article).

Connect Button

Opens a dialog to attach or create credentials for the selected action.

Custom Action (+) - Coming Soon

Enables defining your own API-based operation if it’s not pre-listed.

How to Use

Click Applications.

You’ll see the available systems and their actions.

A list of available integrations appears, choose the desired action.

Example, “Fetch Knowledge Article to Markdown” from Xurrent is selected.

Connect Credentials

You must link a credential to authenticate the selected action.

Options:

Select from Existing Credential: Choose from previously stored credentials (e.g., Mainline).
Add New Credential: Create a new connection using valid API keys or authentication tokens.

Once selected, click Save to bind the credential.

🔒 Security Note: Credentials are securely stored and encrypted within Autom Mate Vault module. Only users with appropriate access can manage or modify them.

Configure the Action

After connecting, configure the key attributes:

Field

Description

Inputs

Defines required parameters the action needs to function (e.g., Request Type ID, Service Desk ID). Each input includes a type and required flag.

Save and Verify

Click Save once configuration is complete.

Text (Manual Entry)

This feature enables users to add textual information directly to train the AI Agent.

Selecting the Text card opens the Add Text window. It contains a simple, editor-style input area supporting basic formatting options:

Bold (B)
Italic (I)
Lists (• / 1.)
Links 🔗
Emoji 😊

Up to 2000 characters can be entered. Once complete, the Finish button saves the entry.

Workflow

Click the Text card.
Type the desired content in the input area.
Use formatting tools if necessary.
Click Finish to save.

The entered text is then indexed into the agent’s vector knowledge base and becomes retrievable during query sessions.

💡 Note: Use this method for short, frequently updated or contextual information — not large documents.

Data Management & Listing

Once added, each data source appears in the lower list labeled:

“All added data sources”

Each entry displays:

Data type (File, Website, Text)
Upload date
Status

If no items exist, an empty-state icon with a neutral message is shown.

Actions – Defining What Your Agent Can Do

The Actions section defines what the AI Agent can do — its functional capabilities. These are API-based or app-based operations that the agent can execute when responding to user queries, such as creating a Jira issue, sending a Slack message, or retrieving customer data.

Actions transform your agent from a conversational interface into a fully functional automation layer that can take contextual decisions and execute them.

Interface Overview

Section

Description

Header Bar

Displays your agent name, last update timestamp, and action count (e.g., 1/20 Actions).

Add Action Button (+)

Opens the configuration window to create a new action.

Actions List

Displays all configured actions with details such as name, creation date, and status.

Action Limit

Each agent supports up to 20 actions.

Status Indicator

Shows whether an action is ready, in progress, or has a configuration issue.

Edit/Delete Controls

Allows modifying or removing actions at any time.

Hint

Write a When to Use description that maps user intents to system actions — this improves AI understanding.
For sensitive or high-impact tasks (e.g., Delete Record), set Action Run Method = Supervised.
Test each new action through the Playground tab to verify correct execution.
Keep total actions under 20 per agent to optimize performance and reasoning accuracy.

Adding a New Action

To define a new action, click the + Add Action button. This opens the Add Action wizard — a step-by-step modal that guides users through creating an action.

Choose Application or Action Type

The first screen lists available integrations (applications) and their ready-to-use actions. Each application card shows its logo, name, and the number of actions available — for example:

App

Available Actions

Salesforce

Stripe

Endpoint Central

Twilio

ServiceNow

Datto RMM

GitLab

Lakeside

AFAS

Azure DevOps

At the top, there is also a Custom Action button for defining manual API calls. This feature coming with next releases.

Select the Action

After selecting an application (e.g., Jira Service Management), a grid of available actions is displayed — such as:

Add Attachment
Add Comment
Create Issue
Delete Issue
Get Issue
Update Issue
HTML ↔ Jira Markdown Converters

Connect Credentials

Before configuring inputs, the system requires authentication. If no credential is linked, the agent cannot perform the action. Below that, the selected operation (e.g., Create Issue) appears, followed by a credential selector.

Two options are provided:

Select from Existing Credential → choose an available API connection (e.g., “Test User”)
Add New Credential → define a new connection (e.g., by entering an API key or OAuth token)

Once a credential is selected, click Save, then Next to continue.

🔐 Note: Credentials are securely stored and managed by Autom Mate Vault. Users must have the correct permissions to add or modify credentials.

Define Action Details

This step lets the user describe the action and define its behavior.

Fields include:

Field

Description

Action Name

The descriptive title for the action (e.g., Create Issue). This helps the agent recognize when to use it.

When to Use

A plain-text explanation describing when the AI should trigger this action. The description should include purpose, context, and sample prompts.

Inputs

Defines the parameters the action needs (explained in the next step).

Action Response Settings - Action Run Method

Controls whether the agent executes the action automatically or with user approval.

Options:

Supervised – requires human confirmation before execution.
Unsupervised – runs automatically when triggered.

All required fields are marked with * (asterisk). Clicking Next or expanding Inputs leads to input mapping.

Configure Inputs

The Inputs section allows defining the parameters that the action requires. For example, a “Create Issue” action might need:

project_key
summary
description
priority

To add input, click + Add → a new input pop-up appears where you can define required input.

Configure Response Settings

Below the input list, you’ll find Action Response Settings, which define how the AI should handle the output.

Option

Description

Action Run Method

Determines how the action executes — currently supports: 🔹 Supervised (requires confirmation before running) 🔹 Unsupervised (executes automatically when conditions are met).

Additional fields (like response formatting) will appear dynamically depending on the application type.

Save the Action

Once all configurations are complete, click Save. The action now appears under the main Actions Added list with:

Column

Example

Action Name

Create Issue

Added On

Oct 07, 2025, 12:42

Status

Ready

Each action can later be:

Edited (to update configuration)
Deleted (to remove it completely)

Example Use Case

Scenario: A support team wants the AI Agent to create Jira tickets when users report issues in chat.

Steps

Create an action → select Jira Service Management.

Choose Create Issue.

Connect a Jira credential.

Define inputs → summary, description, priority.

Describe usage: “When the user says they encountered a bug, create a Jira issue automatically.”

Select Action Run Method

Save the action.

Now, when the agent detects a related query, it will call the Jira API and create the issue automatically.

Once configured, your agent can dynamically trigger these actions in real time based on user intent — seamlessly interacting with business systems, creating records, fetching data, or executing automations on your behalf.

💡 Example: “Create a support request for a VPN issue.” → The agent recognizes the intent, calls Create Customer Request, fills required fields, and executes it (supervised or automatically, based on configuration).

Troubleshooting

Issue

Possible Cause

Solution

Next button disabled

No credential connected

Connect an existing or new credential

Action not triggering

“When to Use” missing or unclear

Provide a precise condition or trigger intent

Error 401 / Unauthorized

Invalid credential or expired token

Reauthenticate or update credentials in Vault

Action fails silently

Missing required input values

Verify that all “Required” parameters are mapped

Channels – Connecting the AI Agent to Communication Platforms

The Channels tab allows you to deploy your AI Agent across multiple communication platforms, enabling it to interact with users wherever they work or communicate. Agents can be embedded in websites, connected to messaging platforms like WhatsApp and Microsoft Teams, or exposed via Webhook endpoints for integration with other systems.

Each channel provides a secure and configurable bridge between Autom Mate’s orchestration layer and external environments.

Interface Overview

Element

Description

Channel Cards

Each supported channel is represented as a tile with an icon, description, and a Setup or Configure button.

Available Channels

WhatsApp · Microsoft Teams · Mate Chat · Webhook

Status Indicators

- 🟢 Green background: Active and connected - ⚪ White background: Not configured

Setup / Configure Buttons

Used to initiate new connections or modify existing ones

Remove (–)

Disconnects the channel and clears its credential link

WhatsApp Integration

Connecting your AI Agent with WhatsApp Business enables automated conversations through WhatsApp chats. Once connected, messages received on the linked WhatsApp account are automatically processed by the agent in real time, allowing seamless customer or internal support interactions.

Setup Process:

WhatsApp Integration Setup

Displays the Webhook URL to be configured in the Meta Business Developer Console:
```
https://aut.autommate.app/api/v1/automs/run/{autom_id}?apiKey={api_key}
```
Includes a link to View Complete Installation Guide.
Describes integration prerequisites (WhatsApp Business Account, verified number, API credentials).

Connect Credential

Choose one of:
- Select from Existing Credential – pick a preconfigured WABA credential.
- Add New Credential – create a new one using WhatsApp Cloud API keys.
After saving, the card turns green and becomes Configurable.

The agent can now respond to WhatsApp messages using the connected WABA account.

💡 Tip: You must have a WhatsApp Business API or Meta-verified account already configured in Autom Mate before enabling this channel.

Microsoft Teams Integration

This integration enables the AI Agent to operate inside Microsoft Teams. Once connected, users can interact with the agent directly through Teams chats or channels — ideal for enterprise environments that already use Teams as their internal communication hub.

Setup Process:

MS Teams ChatBot Installation

Provides a Webhook endpoint for Azure Bot configuration:

https://aut.autommate.app/api/v1/automs/run/{autom_id}?apiKey={api_key}

Guides the user to set this URL in the Azure Bot messaging endpoint field.
Offers a View Complete Installation Guide for setup instructions.

Connect Credential

Options:
- Select from Existing Credential – link to an existing Azure Bot configuration.
- Create New Credential – register a new one for the Teams environment.
Once completed, the Teams card becomes Configured (green).

💡 Tip: The bot must be registered in Azure Active Directory and configured as Multi-Tenant in the Azure portal to enable organization-wide or cross-tenant access.

Embed your AI Agent directly on your website through the Mate Chat widget, enabling visitors to chat with the agent in real time.

Setup Tabs

Tab

Purpose

API Keys

View and manage Public and Private keys for widget authentication. ⚠️ Never expose the private key on client-side code.

CORS Domains

Define whitelisted domains where the widget can be embedded. Wildcards (e.g. *.example.com) are supported.

Embed Script

Provides a ready-to-copy script snippet to paste into your website’s HTML. Must be placed just before the closing </body> tag.

Settings

Customize the widget’s visual style, content, and operational limits.

Settings Tab Details

Field

Description

Primary Color

Sets the widget’s accent color (e.g., #4F6E90).

Agent Name

Display name for the chat widget header.

Welcome Message

Default greeting message displayed when the chat opens.

Logo URL

(Optional) URL to display a logo in the chat header.

Widget Position

Choose widget placement: Bottom Right / Bottom Left.

Rate Limiting

Configure concurrency and throughput caps: • Max Concurrent Sessions: Number of simultaneous chat users (e.g., 15) • Max Requests per Minute: API call limit (e.g., 1000).

Save Changes / Reset

Apply or revert customization settings.

Embed Script Example

<!-- Mate Chat Widget -->
<script>
  (function() {
    var s = document.createElement('script');
    s.src = "https://aut.autommate.app/ai/widget.js";
    s.setAttribute('data-agent-key', 'pk_live_xxxxxxxx');
    s.async = true;
    document.head.appendChild(s);
  })();
</script>

Installation Steps:

Copy the embed script.

Open your site’s HTML file.

Paste before the closing </body> tag.

Save and publish your site.

The widget bubble appears automatically at the chosen position

Webhook Integration

Expose your agent as a programmable API endpoint that can receive and respond to HTTP POST requests.

Setup Process

Displays the agent’s unique Webhook configuration, including request details and an example payload.

Field

Description

Webhook URL

Endpoint used to send messages to the agent: https://aut.autommate.app/api/v1/automs/run/{autom_id}?apiKey={api_key}

HTTP Method

POST

Content-Type

application/json

Payload Example

{ "message": "Hello", "userId": "user123", "sessionId": "session123" }

💡 Example Use Case: An alerting system can automatically trigger the agent when a critical event occurs. The agent can analyze the input, create a ticket via Actions, and respond with remediation steps — all through the Webhook connection.

Channel States

Status

Appearance

Description

Inactive

White card, “Setup” button

Channel not configured yet

Active

Green card, “Configure” button

Channel successfully connected

Removable

Red “–” icon visible

Allows manual channel disconnection

Reconfigurable

Configure modal accessible

Edit settings, credentials, or keys

Logs – Monitor Agent Conversations & Execution

The Logs tab provides full visibility into the conversations, decisions, and actions executed by your AI Agent. It serves as a real-time audit trail — allowing administrators and developers to review how the agent interpreted prompts, executed automations, and interacted with users or external systems.

This area is critical for debugging, compliance tracking, and continuous improvement of agent reasoning and action mapping.

Interface Overview

Section

Description

All Logs Panel (Left Sidebar)

Displays a list of all recorded conversations session by session between the AI Agent and users. Each entry shows: • Conversation title (based on initial user message) • Initiator name (e.g., administrator) • Date • Message count

Conversation Thread (Main Panel)

Shows the full message exchange between the user and agent, in chronological order, including timestamps and confidence scores.

Reasoning Expander

Each agent response can be expanded to show internal reasoning and AI decision confidence metrics.

Confidence Indicator (Green Bar)

Displays the model’s confidence score (e.g., 0.98) for each agent message — helping assess reasoning reliability.

Action Indicator / Error Flag

Displays icons indicating when an action was executed, failed, or required user input (e.g., ⚠️ for validation errors).

Top Bar Controls

Contains key utilities for log management: • Filters – refine logs by date, show only flagged messages, and filter by confidence score • Open in Autom Builder – directly open related automs for debugging • Refresh – reloads latest logs • Export – exports conversation history as a file

Conversation Flow Example

Step

User Message

Agent Response

Notes

“create me a ticket that the subject is my computer is not working”

“Creating a ticket with the subject ‘my computer is not working’ requires approval. Would you like me to proceed?”

The agent interprets intent and requests confirmation.

“yes”

(Action triggered) — Agent begins to create the request.

(System error occurs)

“I tried to create the ticket, but there was an error with the category. Could you please specify the correct category?”

Agent reports validation issue and requests clarification.

“what happened”

Agent clarifies the previous failure reason.

Using the Logs Screen

Interact with your AI Agent via Playground, WhatsApp, Microsoft Teams, or Webhook.
Each message exchange is automatically recorded and listed in the All Logs panel.
Select a conversation to view its message history in the right-hand panel.
Use Refresh to update the list in real time, or Export to download logs for review

The Logs tab provides a unified, searchable history of all agent conversations — complete with message flow, reasoning transparency, and performance analytics. It’s your agent’s control room for understanding, debugging, and continuously improving how Autom Mate’s AI orchestrates real-world automations.

💡 Example: You can review how the agent handled a failed Jira ticket creation, view the reasoning path, confidence level, and action payload — then instantly open the related Autom in Autom Builder to fix the root cause.

Additional Tips

Use Case: AI-Powered IT Help Desk Automation with Autom Mate AI Agent Composer

This use case demonstrates how Autom Mate’s AI Agent Composer can transform traditional IT support workflows into fully automated, intelligent, and supervised operations. By combining AI reasoning, knowledge integration, and real-world automation skills, the IT Help Desk can handle issue creation, categorization, and ticket submission autonomously — freeing human teams for higher-value work.

Problem Statement

Traditional chatbots in IT operations can only provide predefined answers. They lack the ability to:

Understand user intent deeply
Execute actions across enterprise systems
Learn and adapt through context
Operate within secure, auditable boundaries

As a result, IT teams spend time on repetitive ticket management, password resets, and routine service requests that could be safely automated.

Solution

Using Autom Mate AI Agent Composer, organizations can design and deploy an AI Help Desk Agent capable of:

Understanding natural language user requests
Retrieving internal knowledge for accurate responses
Executing automated workflows in systems like Jira, Azure, or Salesforce
Operating in supervised or autonomous modes depending on compliance requirements

This transforms the AI from a passive chatbot into an active, digital workforce member.

Steps

1. Define the Agent Role

Create a new AI agent in Autom Mate and define its role — e.g., IT Help Desk Agent. Assign a clear purpose and tone using a prompt such as:

“You are a professional IT support assistant responsible for creating, updating, and managing service requests.”

This defines the agent’s boundaries and personality for every interaction.

2. Provide Knowledge

Enhance the agent’s expertise by adding organization-specific knowledge:

Upload internal troubleshooting guides or FAQs
Connect to relevant IT service documentation or portals
Include plain-text descriptions of escalation processes

This ensures that every answer reflects your own policies and systems — not generic internet information.

3. Assign Skills

Grant your agent actionable skills through Autom Mate’s integration library, for example:

Create Jira Ticket
Reset Azure Password
Provision Salesforce User

In this scenario, the Create Jira Ticket skill is used to enable the agent to generate and manage incidents directly within Jira.

4. Deploy Across Channels

Once configured, deploy the agent where users interact daily:

Microsoft Teams – for internal support
WhatsApp or Web Chat – for customer service portals
API Webhooks – for external systems or applications

The agent becomes available wherever requests originate.

5. Supervise and Improve

Activate Supervised Mode to ensure safe operation:

The agent gathers required data and proposes an action
It pauses for approval before executing
All reasoning and steps are visible in Logs for audit and optimization

This approach builds operational trust before moving to full autonomy.

Example Scenario

User Interaction:

“Create me a ticket. My computer is not turning on.”

Agent Response:

Understands intent and identifies the action as Create Jira Ticket.
Requests necessary inputs (project, issue type, summary, description).
Summarizes the planned action for confirmation.
Waits for user approval (supervised mode).
Executes the action, confirms creation, and provides the Jira ticket number.

Outcome: A complete end-to-end IT service request process completed through a single chat interaction — securely logged and traceable.

Benefits

Efficiency

Automates repetitive tasks like ticket creation and categorization.

Accuracy

Reduces manual entry errors through guided AI workflows.

Scalability

Handles unlimited concurrent requests across multiple channels.

Transparency

Supervised mode with detailed logs ensures auditability.

User Experience

Delivers instant, conversational IT support.

In just minutes, the IT Help Desk agent evolves from a simple chatbot into a fully functional digital team member capable of orchestrating cross-system workflows. This use case demonstrates how Autom Mate’s AI Agent Composer enables the shift from static automation to dynamic, intelligent operations — where human expertise and AI autonomy work together seamlessly.

How to create Custom Data Source Autom (RAG Autom)

This Autom orchestrates all data-source operations for the AI Agent — file uploads, text entries, website crawling, app integrations, and deletions — through a unified RAG (Retrieval-Augmented Generation) pipeline. Whenever a user interacts with the Data Sources tab, this Autom is triggered and processes the corresponding workflow branch based on ##triggerParam[type]##.

Architecture Overview

TRIGGER → START → IF (event == "agent_rag")
        └── Rag Group
              └── SWITCH (##triggerParam[type]##)
                    ├── file        → File upload & embedding verification
                    ├── text        → Manual text input
                    ├── crawl_url   → Website discovery (link listing)
                    ├── crawl       → Website content processing
                    ├── app         → External app data (e.g., Xurrent)
                    └── delete      → Vector store deletion

1️. Entry Layer

🔹 Trigger

The trigger initiates this Autom whenever an AI Agent data-source event occurs. Example payload:

{
  "event": "agent_rag",
  "type": "file",
  "file": {
    "file_name": "manual.pdf",
    "content": "base64_encoded_string"
  }
}

The Autom then routes execution to the appropriate case depending on type (file, text, crawl, app, delete).

🔹 IF (Action Library: CONDITION)

Condition: ##triggerParam[event]## == "agent_rag"

Ensures the Autom only executes for RAG-related events, preventing unnecessary or accidental triggers.

2️. Rag Group

The Rag Group acts as the central orchestrator for all RAG data-handling workflows. Each data type is processed as an isolated case within this group.

Action Libraries Used: CONDITION, BASE64, STRING, ARRAY, PYTHON, FLOW, XURRENT

3️. Case: `file` — File Upload

This case manages files uploaded through the AI Agent interface. Files arrive in Base64 format and must be decoded, written to the local environment, and tracked until their embeddings are fully processed.

3.1 File Upload Sequence

Action Steps:

STRING → ASSIGN
- Input: ##triggerParam[file][file_name]##
- Output: file_name → Extracts and stores the file name dynamically.
BASE64 → DECODE
- Base64 Code: ##triggerParam[file][content]##
- Folder Path: mate:/
- File Name: ##file_name##
- Output Variable: file_md_path → Decodes Base64 data and writes the physical file into Autom Mate’s local directory.
ARRAY → ADD
- Array: ##file_md_paths##
- Item: {"file_name":"##file_name##","file_path":"##file_md_path##"} → Keeps track of uploaded file paths for later embedding and indexing.

3.2 Status Verification Group — “Check Status Loop”

Once a file is uploaded, it is asynchronously embedded into the vector store (e.g., OpenAI). This Check Status Loop ensures the Autom waits until the embedding is complete before returning a success response.

Group Logic

REST API (GET) — Status Check
- Endpoint: https://api.openai.com/v1/vector_stores/files/##vector_file_id##
- Output Variable: status_response → Fetches the current embedding status (in_progress, complete).
TEXT → EQUALS CHECK
- Condition: ##status_response[status]## == "complete" → If not complete, continues looping.
TIME → WAIT
- Wait Time: ~3–5 seconds → Introduces delay to reduce API load.
Nested Group: “status equals complete”
- ARRAY → ADD → Adds finished file to completed_files.
- FLOW → BREAK → Exits loop.

This logic guarantees that no file is reported as “uploaded” until its embeddings are fully indexed in the vector store.

3.3 Completion Response

_{FLOW → STOP & RETURN}

{
  "status": true,
  "message": "File(s) uploaded and indexed successfully",
  "files": ##completed_files##
}

4️. Case: `text` — Manual Text Entry

Handles direct text inputs added via the “Text” card. The text is encoded, written to file, and integrated into the RAG knowledge base.

Libraries Used: STRING, BASE64, ARRAY

Sequence:

STRING → file_name
STRING → text_data
BASE64 → ENCODE → b64_code
BASE64 → DECODE → Creates .md file
ARRAY → ADD → Appends to file_md_paths

This process turns short manual entries into retrievable Markdown files for the AI Agent.

5️. Case: `crawl_url` — Website Discovery

Triggered when the user clicks “Load Links” in the “Public Website” card. Discovers internal pages of a specified domain.

Library: PYTHON

Script Functionality:

Fetches the root webpage with requests
Parses <a href> tags using BeautifulSoup
Filters internal links belonging to the same domain
Outputs the list into the variable urls

Output Example:

{
  "status": true,
  "urls": [
    "https://docs.autommate.com/start",
    "https://docs.autommate.com/userguide"
  ]
}

This prepares the next case (“crawl”) to process content from those URLs.

6️. Case: `crawl` — Website Content Processing

Uses the discovered links to retrieve each page’s content, converts it into Markdown, and stores it for vector indexing.

Library: PYTHON

Script Workflow:

Iterates through ##triggerParam[urls]##
Fetches each HTML page
Strips unnecessary tags
Converts clean text to Markdown
Saves to mate:/
Updates file_md_paths list

Each crawled page becomes a new Markdown knowledge file for the AI Agent.

7️. Case: `app` — External Applications (Xurrent Example)

This case connects Autom Mate to third-party systems like Xurrent, ServiceNow, or Jira using Action Libraries instead of manual REST calls.

7.1 Identify App Action

STRING → ASSIGN ##triggerParam[action_id]##_##triggerParam[unique_id]## → app_action

Combines identifiers to determine which prebuilt Action Library to execute.

7.2 SWITCH (##app_action##)

Manages multiple app-specific actions. Currently active example:

📘 Xurrent – Fetch Knowledge Article to Markdown

7.3 Action Library: Xurrent – Fetch Knowledge Article to Markdown

A prebuilt Action Library that fetches knowledge articles directly from Xurrent. No manual REST configuration is required — only credentials and parameters.

Configuration Fields

Field

Type

Description

App Credential

Required

Defines which Xurrent account or token to use. Example: 44ME.

Knowledge Article ID

Required

Select or manually enter the target article. Example: (Re)Installation of the Vanta Agent.

Output

Required

Output variable for Markdown content. Example: FetchKnowledgeArticleToMarkdown.

Execution Logic

Authenticates via selected credential.
Fetches the chosen article content from Xurrent.
Converts it to Markdown format.
Saves the result into the FetchKnowledgeArticleToMarkdown variable.
Adds it to the AI Agent’s knowledge list (file_md_paths).

This demonstrates Autom Mate’s Action Libraries framework — providing pre-integrated, no-code connectivity to enterprise systems.

8. Case: `delete` — Vector Store Deletion

Removes files previously indexed in the vector store.

Action Library: REST API (DELETE)

Field

Value

URI

https://api.openai.com/v1/vector_stores/##triggerParam[vector_store_id]##/files/##repeat_string##

Headers

Authorization: Bearer ##token##, OpenAI-Beta: ##openai_header##

Response Example:

{
  "status": true,
  "message": "File(s) deleted successfully"
}

Summary

This Autom unifies all data-source operations into a single, intelligent RAG pipeline.

Operation

Description

File

Decodes uploads, tracks embedding status, confirms completion

Text

Converts short entries into retrievable Markdown files

Crawl_URL

Discovers domain links for later ingestion

Crawl

Extracts and transforms website content into Markdown

App (Xurrent)

Retrieves external knowledge articles via Action Libraries

Delete

Removes indexed files from the vector store

Each step is implemented with Autom Mate Action Libraries, eliminating manual REST configuration and ensuring a secure, maintainable, and reusable RAG foundation for the AI Agent.

Here is the example Autom

147KB

Canakkale Test RAG.json

Open

PreviousProduct Features NextMSP HUB

Last updated 1 month ago

Introduction

Agents Page

Creating an Agent

Configuration Fields

Example Prompt

Deployment

Managing the Agent's Autom

Autom View

Editing the Autom

Trigger Method

Playground — Real-Time Agent Testing

Interface Breakdown

How to Use

What to Check

Data Sources – Managing Agent Knowledge Inputs

Upload Files

How to Use

Public Websites

How to Use

Applications (Third-Party Sources)

Hints

Interface Overview

How to Use

Text (Manual Entry)

Workflow

Data Management & Listing

Actions – Defining What Your Agent Can Do

Interface Overview

Hint

Adding a New Action

Choose Application or Action Type

Select the Action

Connect Credentials

Define Action Details

Configure Inputs

Configure Response Settings

Save the Action

Troubleshooting

Channels – Connecting the AI Agent to Communication Platforms

Interface Overview

WhatsApp Integration

Microsoft Teams Integration

Mate Chat (Web Embed Widget)

Webhook Integration

Channel States

Logs – Monitor Agent Conversations & Execution

Interface Overview

Conversation Flow Example

Using the Logs Screen

Additional Tips

Use Case: AI-Powered IT Help Desk Automation with Autom Mate AI Agent Composer

Problem Statement

Solution

Steps

1. Define the Agent Role

2. Provide Knowledge

3. Assign Skills

4. Deploy Across Channels

5. Supervise and Improve

Example Scenario

Benefits

How to create Custom Data Source Autom (RAG Autom)

Architecture Overview

1️. Entry Layer

2️. Rag Group

3️. Case: file — File Upload

4️. Case: text — Manual Text Entry

5️. Case: crawl_url — Website Discovery

6️. Case: crawl — Website Content Processing

7️. Case: app — External Applications (Xurrent Example)

8. Case: delete — Vector Store Deletion

Summary

3️. Case: `file` — File Upload

4️. Case: `text` — Manual Text Entry

5️. Case: `crawl_url` — Website Discovery

6️. Case: `crawl` — Website Content Processing

7️. Case: `app` — External Applications (Xurrent Example)

8. Case: `delete` — Vector Store Deletion