Architecture

Introduction

Welcome to the Agent Architecture Platform Guide. This guide provides detailed instructions on how to create, configure, and deploy AI Agents in our platform to enhance your workflows. AI Agents are versatile tools that can assist with various tasks, such as answering questions, performing actions, and interacting with users through channels like Microsoft Teams or phone calls. The primary use case is L1 support, but Agents can be adapted to any workflow where automation and AI assistance are beneficial. This guide is divided into three main sections:

Agent Platform – Creating and configuring Agents.
Tools – Configuring tools that Agents can use to perform actions.
Deploying Agents into Workflows – Integrating Agents into workflows and external channels.

Each section includes step-by-step instructions and examples to help you understand when and how to use each feature.

Agent Platform

Creating and Configuring Agents

AI Agents are created and configured within the context of an App’s workflow. Follow these steps to create a new Agent:

Navigate to App Configuration:
- Go to the App where you want to add the Agent.
- Access the App configuration section.
Add an Agent:
- Select the option to add an Agent to the App.
- You can view existing Agents assigned to the App or create a new one.
Create a New Agent:
- Name the Agent: Provide a unique name for the Agent.
- Add a Description: Describe how the Agent fits into your organization and its intended use case.
- Select the LLM Model: Choose the Large Language Model (LLM) to power the Agent (e.g., Claude Sonnet 3.5 or 3.7 from Snowflake Cortex, if configured).
  - If no models are available, follow the link to set up a new AI Service and Provider.
- Enter Training Instructions: Provide additional instructions to guide the Agent’s behavior.
- Start a Conversation: Test the Agent by starting a conversation. You can clear the conversation and start a new one if needed.
- Save the Agent: Once configured, save the Agent to create its profile.
View and Edit Agent Profile:
- From the Agent profile, you can edit the configuration or start a new conversation to further test the Agent.

Example Use Case:

L1 Support: Create an Agent named “SupportBot” with a description like “Handles initial customer queries and creates tickets.” Use Claude Sonnet 3.5 and train it to ask users for issue details.

Assigning Agents to Apps

Agents can be assigned to participate in an App:

During App configuration, select existing Agents or create new ones to include in the App.

Example Use Case:

HR Onboarding: Assign an Agent to an HR App to assist new employees with onboarding tasks.

Tools

Tools enable Agents to perform specific actions, such as creating, searching, or updating records, running automations, delegating to sub-agents, or connecting to external services via MCP. Below are the tools available for configuration.

Skills

Agents can dynamically discover and run modular capabilities at runtime using Skills. Skills are reusable modules (name, description, instructions, and automation tools) managed under Intelligence → Skills. When Skills are enabled for an agent, it receives automatic tools to search for and execute Skills based on context—no manual tool setup required. For setup, lifecycle (draft/active/disabled), and the enabledSkills modes (none, all, selected, filter), see Agent Skills.

Create Record Tool

The Create Record Tool allows the Agent to create new records in the system. Configuration Steps:

Add the Tool: When configuring an Agent, select the option to add a Create Record Tool.
Name the Tool: Provide a unique name for the tool.
Add a Description: Describe when and how the Agent should use this tool.
Set Tool Start Message: Customize what the user sees or hears when the tool runs.
Select Run As Mode: Choose how the Agent executes the tool:
- Run as publisher (default): Agent runs with the publisher’s permissions.
- Run as current user: Agent runs with the current user’s permissions.
- Run as service account: Agent runs with a specific service account.
Select App/Element/Task: Choose the specific App, Element, or Task that the Agent can create.
Specify Fields:
- Required Fields: These are shown by default and cannot be removed.
- Optional Fields: Add any additional fields the Agent may need to fill out.
- Field Descriptions: For each field, provide a description to guide the Agent on how to obtain the necessary data.
Select Fields to Return: Choose which fields from the created record should be sent back to the Agent.
Save the Tool: Once all fields have descriptions, save the tool.

Example Use Case:

L1 Support: Configure the tool to create a support ticket with fields like “Issue Description” (required) and “Priority” (optional). The Agent asks the user for details and returns the ticket ID.

Record Search Tool

The Record Search Tool enables the Agent to search for existing records based on a query. Configuration Steps:

Add the Tool: Select the option to add a Record Search Tool.
Name the Tool: Provide a unique name.
Add a Description: Explain when the Agent should use this tool.
Set Tool Start Message: Customize what the user sees or hears when the tool runs.
Select Run As Mode: Choose how the Agent executes the tool:
- Run as publisher (default): Agent runs with the publisher’s permissions.
- Run as current user: Agent runs with the current user’s permissions.
- Run as service account: Agent runs with a specific service account.
Select App/Element/Task: Choose the App, Element, or Task to search.
Add Query Description: Provide guidance on what the Agent should search for.
(Optional) Select Fields to Return: Choose which fields from the search results should be returned to the Agent.
Save the Tool: Once configured, save the tool.

Behavior:

The search returns results similar to a list view search.
If more than 100 records are found, the Agent receives a failure message indicating the need for a more refined query.

Example Use Case:

L1 Support: The Agent searches for existing tickets with a query like “Find tickets related to login issues” and returns ticket summaries to the user.

Update Record Tool

The Update Record Tool allows the Agent to update existing records. Configuration Steps:

Add the Tool: Select the option to add an Update Record Tool.
Name the Tool: Provide a unique name.
Add a Description: Describe when the Agent should use this tool.
Set Tool Start Message: Customize what the user sees or hears when the tool runs.
Select Run As Mode: Choose how the Agent executes the tool:
- Run as publisher (default): Agent runs with the publisher’s permissions.
- Run as current user: Agent runs with the current user’s permissions.
- Run as service account: Agent runs with a specific service account.
Specify Record Identification: Explain how the Agent should identify the record to update (e.g., by record ID).
Select App/Element/Task: Choose the App, Element, or Task to update.
Specify Fields to Update:
- Mark the fields the Agent must update.
- Provide descriptions for each field to guide the Agent.
Save the Tool: Once all fields have descriptions, save the tool.

Behavior:

The Agent is notified whether the update was successful or not, along with reasons for failure, allowing it to attempt corrections.

Example Use Case:

L1 Support: After resolving an issue, the Agent updates a ticket’s status to “Closed” using the ticket ID provided by the user.

AI Search Records Tool

The AI Search Records Tool provides advanced search capabilities using AI, allowing the Agent to understand and retrieve related data based on natural language. Configuration Steps:

Add the Tool: Select the option to add an AI Search Records Tool.
Name the Tool: Provide a unique name.
Add a Description: Explain when the Agent should use this tool.
Set Tool Start Message: Customize what the user sees or hears when the tool runs.
Select Run As Mode: Choose how the Agent executes the tool:
- Run as publisher (default): Agent runs with the publisher’s permissions.
- Run as current user: Agent runs with the current user’s permissions.
- Run as service account: Agent runs with a specific service account.
Select App/Element/Task: Choose the App, Element, or Task to search.
Set Result Limit: Specify the maximum number of results to return (1-100, default is 10).
Configure AI Search:
- Select the AI Search configuration for the object.
- Choose attribute fields to search on and set up any necessary filters.
- Provide descriptions for each field to guide the Agent.
Select Fields to Return: Choose which fields from the search results should be sent back to the Agent.
Save the Tool: Once configured, save the tool.

Example Use Case:

Sales Assistance: The Agent uses AI search to find customer records with a query like “Customers interested in Product X” and returns contact details.

Run Automation Tool

The Run Automation Tool allows the Agent to execute existing automations that have an On-Demand trigger, enabling complex workflows to be triggered conversationally. Configuration Steps:

Add the Tool: Select the option to add a Run Automation Tool.
Name the Tool: Provide a unique name (no spaces or special characters allowed).
Add a Description: Describe when and how the Agent should use this tool.
Set Tool Start Message: Customize what the user sees or hears when the tool runs.
Select Run As Mode: Choose how the Agent executes the automation:
- Run as publisher (default): Agent runs with the publisher’s permissions.
- Run as current user: Agent runs with the current user’s permissions.
- Run as service account: Agent runs with a specific service account.
Select Automation: Choose an existing automation with an On-Demand trigger.
Define Input Values: Specify the input parameters the Agent will pass to the automation, including field names and descriptions.
Define Output Values: Specify which output values the Agent will receive from the automation.
Save the Tool: Once configured, save the tool.

Behavior:

The automation executes with the configured permissions.
Input values are collected from the conversation context based on field descriptions.
Output values are returned to the Agent for use in the conversation.

Example Use Case:

Order Processing: The Agent triggers an “Order Lookup” automation, passing the order ID as input and receiving shipment status as output to share with the user.

Run Agent Tool

The Run Agent Tool allows the Agent to delegate tasks to another agent (sub-agent) for specialized processing. Each execution creates a new conversation between the main agent and the sub-agent. Configuration Steps:

Add the Tool: Select the option to add a Run Agent Tool.
Name the Tool: Provide a unique name (no spaces or special characters allowed).
Add a Description: Describe when and how the Agent should use this tool.
Set Tool Start Message: Customize what the user sees or hears when the tool runs.
Select Run As Mode: Choose how the Agent executes:
- Run as publisher (default): Agent runs with the publisher’s permissions.
- Run as current user: Agent runs with the current user’s permissions.
- Run as service account: Agent runs with a specific service account.
Select App: Choose the App containing the target agent.
Select Target Agent: Choose the sub-agent to delegate tasks to.
Add Worker Task Prompt: Provide instructions for how this agent should delegate tasks to the worker agent.
Save the Tool: Once configured, save the tool.

Behavior:

Each tool execution starts a new conversation with the sub-agent.
The main agent can provide context and instructions to the sub-agent.
Results from the sub-agent are returned to the main agent for continued processing.

Example Use Case:

Multi-Department Support: A main support Agent delegates technical questions to a specialized “Technical Expert” sub-agent, which has access to technical documentation and troubleshooting tools.

MCP Tool

The MCP (Model Context Protocol) Tool allows the Agent to connect to external MCP servers and use custom tools, extending the Agent’s capabilities beyond the platform’s built-in tools. Configuration Steps:

Add the Tool: Select the option to add an MCP Tool.
Connect to MCP Server:
- Enter MCP Server URL: Provide the base URL of the MCP server (e.g., https://api.example.com/mcp).
- Configure Authentication: Select the authentication method:
  - Bearer Token: Enter an access token.
  - Basic Auth: Enter username and password.
  - API Key: Enter the API key.
  - None: No authentication required.
- Connect to discover available tools.
Select Tool: Browse and select from the tools available on the MCP server.
Configure Tool:
- Name the Tool: Provide a unique name (no spaces or special characters allowed).
- Add a Description: Describe when and how the Agent should use this tool.
- Set Tool Start Message: Customize what the user sees or hears when the tool runs.
- Select Run As Mode: Choose the execution permissions.
Save the Tool: Once configured, save the tool.

Behavior:

The Agent communicates with the external MCP server to execute the tool.
Authentication is handled automatically based on the configured method.
Results are returned to the Agent for use in the conversation.

Example Use Case:

Third-Party Integrations: Connect to an external shipping provider’s MCP server to give the Agent a “Track Shipment” tool that queries real-time delivery status from the provider’s API.

Deploying Agents into Workflows

Agents can be deployed into workflows and integrated with external channels like Microsoft Teams or phone calls to provide real-time assistance.

Assigning Agents to Workflows

You can assign an Agent to a workflow by creating an “Assign an Agent” button in the record details. Configuration Steps:

Create the Button: In record details configuration, select the option to create an “Assign an Agent” button.
Select or Create an Agent:
- Choose an existing Agent or create a new one.
- If creating a new Agent, follow the steps in section 1.1.
Configure the Agent:
- Name and Icon: Provide a name and select a profile icon.
- Descriptions: Enter descriptions of the Agent’s tasks and capabilities.
- Upload Documents: Add any documents the Agent can use during tasks.
- Configure Tools: Assign tools the Agent can use (see section 2).
Set Initial Message:
- Create an initial message that can reference values from the record.
- Choose whether to:
  - Show First Message: Display the message to the user to explain the Agent’s capabilities.
  - Take Immediate Action: Send the message as a request for the Agent to start working immediately.
Name and Style the Button:
- Provide a name for the button.
- Choose the button style: Primary, Secondary, Inline, or Icon.
Save the Button: Once configured, save the button.

Behavior:

When a user clicks the button in record details, the record chat opens, allowing interaction with the Agent.

Example Use Case:

L1 Support: A fulfiller clicks “Assign SupportBot” on a ticket to have the Agent gather more details from the user.

Integrating with Microsoft Teams

Agents can be integrated with Microsoft Teams to provide assistance through chat. Configuration Steps:

Install the Bot: Select Microsoft Teams and install the Bot into your organization.
Select an Agent: Choose the Agent that will respond to messages.
Specify Fields:
- Select fields to save the email and full name of the user who started the conversation.
Set Timeout: Define how long the conversation remains open without user response before closing.
Train the Agent: Provide instructions on how the Agent should determine when the conversation is finished.
Save Configuration: Ensure only one route is active.

Behavior:

Conversations are tagged for viewing on the record.
When the conversation ends (either by completion or timeout), an automation trigger fires, and a message is sent to Teams.
A “typing” indicator shows when the Agent is processing a response.
The Agent has a tool to access the record context.

Example Use Case:

L1 Support: A user messages the Agent in Teams about a login issue, and the Agent creates a ticket while saving the user’s email.

Integrating with Phone Calls

Agents can handle phone calls to start workflows or provide assistance. Configuration Steps:

Configure Phone Numbers:
- In App Details, view or add new phone numbers using Twilio (Client ID, Client Secret, Phone Number).
- Delete unused phone number configurations.
Enable Phone Call Workflow Start:
- In Flow configuration, specify that the App can be started with a phone call.
- Select a phone number and an Agent to answer the call.
Configure the Agent:
- Provide additional training instructions.
- Set the first message the Agent should say when answering.
- Specify fields to save the caller’s phone number, call summary, and call evaluation.
- Configure prompts for the summary and evaluation.
Save Configuration: Ensure the conversation is saved and viewable on the record.

Behavior:

When a user calls the configured number, the Agent answers and interacts based on the configuration.
After the call, the summary and evaluation are saved to the specified fields.

Example Use Case:

L1 Support: A user calls to report a hardware failure, and the Agent creates a ticket with a summary like “User reported broken monitor.”

External Agents via App Intelligence

In addition to creating and managing internal agents, Elementum supports integration with external agents configured at the App level through Intelligence settings. This enables you to leverage specialized AI capabilities from external providers like Snowflake Cortex and AWS Bedrock while maintaining data security and governance.

External Agent Configuration

External agents are configured at the App level through Intelligence settings, not centrally. This approach ensures:

App-Specific Context: Agents access only the data relevant to their App
Scoped Permissions: Security controlled through AI Provider credentials
Independent Configuration: Each App can configure agents according to its needs
Flexible Deployment: Different Apps can select different providers and agents

Key Concepts:

Native Agents: Built and hosted in Elementum
Managed Agents: External agents (like Cortex or Bedrock) integrated through App Intelligence
App Intelligence: Configuration area where external agents are discovered and connected
AI Provider: Provider configured with appropriate credentials for agent discovery and invocation

Snowflake Cortex Agents Integration

One of the primary use cases for external agents is integrating Snowflake Cortex Agents into your Apps. Cortex Agents run directly on your Snowflake data warehouse, providing AI-powered automation without moving data outside your secure environment. Configuration Steps:

Navigate to App Intelligence:
- Go to the App where you want to use Cortex Agents
- Under App Admin, select Intelligence
Add External Agent:
- Click “Add Agent” button
- Select “External” as the agent type
- Choose a Snowflake AI Provider from the dropdown
Discover and Select:
- Elementum queries Snowflake Cortex REST API through the provider
- Available Cortex Agents are displayed
- Select the agent you want to use
- Configure agent settings and save
Use in Automations:
- When configuring automation actions
- Select the external agent from available agents
- Configure input parameters and output handling
- Set timeout and error handling options

Benefits of Snowflake Cortex Agents:

Data Security: AI runs on your data warehouse—data never leaves your environment
Performance: Direct access to data eliminates transfer latency
Compliance: Maintains data governance and regulatory requirements
Scalability: Leverages Snowflake’s compute infrastructure

Example Use Case:

Automated Data Analysis: When a monthly report is requested, an automation invokes a Cortex Agent to analyze sales trends, generate insights in natural language, and populate the report automatically—all while the data remains secure in Snowflake.

AWS Bedrock Agents Integration

Another key integration is with AWS Bedrock Agents. Bedrock Agents leverage Amazon’s foundation models and can be enhanced with action groups, knowledge bases, and guardrails to create sophisticated AI assistants that integrate with your AWS infrastructure. Configuration Steps:

Navigate to App Intelligence:
- Go to the App where you want to use Bedrock Agents
- Under App Admin, select Intelligence
Add External Agent:
- Click “Add Agent” button
- Select “External” as the agent type
- Choose a Bedrock AI Provider from the dropdown
Connect Agent:
- Enter the Agent Alias ARN from your AWS Bedrock configuration
- Elementum validates the connection through the provider
- Configure agent settings and save
Use in Automations:
- When configuring automation actions
- Select the external Bedrock agent from available agents
- Configure input parameters and output handling
- Set timeout and error handling options

Benefits of AWS Bedrock Agents:

AWS Ecosystem Integration: Native integration with AWS services, Lambda functions, and S3
Knowledge Bases: Connect agents to enterprise knowledge stored in S3 or other AWS data sources
Action Groups: Define custom actions using Lambda functions for complex business logic

Example Use Case:

Customer Service Automation: When a support request is created, an automation invokes a Bedrock Agent that accesses knowledge bases, retrieves customer history, and provides contextual responses—all within your AWS environment.

Agent Discovery and Management

External agents are discovered through their respective AI Providers: Snowflake Cortex Agents:

App Intelligence prompts for Snowflake AI Provider selection
Selected provider’s CloudLink authenticates with Snowflake
Queries Snowflake Cortex REST API for available agents
Retrieves agent metadata (capabilities, schemas, permissions)
Displays available agents for selection
Registers selected agents for use in App automations

AWS Bedrock Agents:

App Intelligence prompts for Bedrock AI Provider selection
Selected provider authenticates with AWS using configured credentials
User provides the Agent Alias ARN for the target agent
Elementum validates connectivity via the InvokeAgent API
Agent is registered for use in App automations

Management:

Per-App Configuration: Each App configures its own external agents
Provider-Based Access: Apps select from configured AI Providers
Intelligence Dashboard: View configured external agents in App Intelligence
Provider Dependency: Agent availability depends on provider health
Centralized Visibility: View all agents across Apps in Agent Orchestration Center

Technical Integration

External agents integrate with Elementum automations through App Intelligence. The flow varies slightly by provider type: Snowflake Cortex Integration: AWS Bedrock Integration: Security Model:

Snowflake: Authentication via CloudLink credentials, permissions enforced at Snowflake level, data governed by Snowflake RBAC
AWS Bedrock: Authentication via IAM credentials (Access Key/Secret Key), permissions enforced by IAM policies, data governed by AWS IAM
Both: All interactions audited, app-level isolation with provider-based access controls

For detailed setup instructions, see:

Agent Orchestration Center - View and manage all agents across organization
Snowflake Cortex Agents Setup Guide - Step-by-step Snowflake configuration
AWS Bedrock Agents Setup Guide - Step-by-step AWS Bedrock configuration

Agent-to-Agent Protocol (A2A)

Elementum supports the Agent-to-Agent (A2A) protocol, an open standard that enables external systems to communicate with Elementum agents programmatically. This allows other AI agents, automation platforms, or custom applications to interact with your Elementum agents as remote collaborators.

A2A Protocol Overview

The A2A protocol facilitates communication between independent AI agent systems. Elementum implements version 0.3.0 of the A2A specification, which provides:

Agent Discovery: External systems can query an Elementum agent’s capabilities through an Agent Card
Task Management: Create, monitor, and manage tasks through standardized API calls
Streaming Responses: Receive real-time updates as agents process requests
Multi-Turn Interactions: Support for conversational exchanges where agents can request additional input

The A2A protocol is an evolving standard. The examples in this documentation reflect Elementum’s current implementation. Contact your Elementum representative if you have questions about integration.

Connecting to an Elementum Agent via A2A

External systems can connect to Elementum agents that have been configured for A2A access. The connection follows the standard A2A handshake pattern: 1. Discover Agent Capabilities Each Elementum agent has a unique A2A endpoint URL in the format:

https://agent-{agentId}-{orgDomain}.elementum.io/a2a/v1

Retrieve the Agent Card to understand the agent’s capabilities, supported input/output modes, and available skills:

GET https://agent-{agentId}-{orgDomain}.elementum.io/a2a/v1/.well-known/agent.json

The Agent Card response includes:

Agent name and description
Supported protocol versions
Available skills and their descriptions
Authentication requirements
Capability flags (streaming, push notifications)

2. Send a Message to Initiate a Task Use the message/send method to start an interaction:

{
  "jsonrpc": "2.0",
  "method": "message/send",
  "params": {
    "message": {
      "role": "user",
      "parts": [
        {
          "kind": "text",
          "text": "Create a support ticket for login issues"
        }
      ]
    }
  },
  "id": 1
}

3. Receive Task Response The agent returns a JSON-RPC response containing a Task object. The response includes a contextId that you can use for follow-up messages:

{
  "jsonrpc": "2.0",
  "id": "1",
  "result": {
    "id": "8f1dfa7f-76c3-4368-8799-3116df7f7992",
    "contextId": "7584685c-e711-4e91-8d8e-e11484bff7b5",
    "status": {
      "state": "completed"
    },
    "history": [
      {
        "role": "user",
        "parts": [{"kind": "text", "text": "Create a support ticket for login issues"}],
        "taskId": "8f1dfa7f-76c3-4368-8799-3116df7f7992",
        "contextId": "7584685c-e711-4e91-8d8e-e11484bff7b5"
      }
    ],
    "artifacts": [
      {
        "artifactId": "6299dcdc-0774-41a7-b35c-0018b1fbbba3",
        "parts": [{"kind": "text", "text": "Support ticket #12345 created successfully."}]
      }
    ],
    "kind": "task"
  }
}

Streaming Responses

Elementum agents support streaming responses, delivering real-time updates as tasks are processed. This is useful for long-running operations or when you want to display incremental progress to users. Initiating a Streaming Request Use the message/stream method instead of message/send:

{
  "jsonrpc": "2.0",
  "method": "message/stream",
  "params": {
    "message": {
      "role": "user",
      "parts": [
        {
          "kind": "text",
          "text": "Analyze the quarterly sales data"
        }
      ]
    }
  },
  "id": 1
}

Receiving Streaming Events The response uses Server-Sent Events (SSE) format. Each event is a JSON-RPC response with a type field indicating the event type:

Type	Description
`status`	Task status changes (working, completed, failed, etc.)
`artifact`	Artifact content chunks as they’re generated

Example SSE Stream: Initial status event indicating the task is being processed:

data:{"result":{"taskId":"0ca889db-417e-45f5-bd85-009637754bb9","contextId":"3cd9546a-68e5-432a-b8db-7743dd6f1909","status":{"state":"working"},"type":"status","final":false},"id":"1","jsonrpc":"2.0"}

Artifact chunks stream incrementally as the agent generates a response:

data:{"result":{"taskId":"0ca889db-417e-45f5-bd85-009637754bb9","contextId":"3cd9546a-68e5-432a-b8db-7743dd6f1909","artifact":{"artifactId":"d706c64d-5167-4a13-baee-e39e61184704","parts":[{"kind":"text","text":"Hi"}]},"append":true,"lastChunk":false,"type":"artifact"},"id":"1","jsonrpc":"2.0"}

data:{"result":{"taskId":"0ca889db-417e-45f5-bd85-009637754bb9","contextId":"3cd9546a-68e5-432a-b8db-7743dd6f1909","artifact":{"artifactId":"d706c64d-5167-4a13-baee-e39e61184704","parts":[{"kind":"text","text":" there"}]},"append":true,"lastChunk":false,"type":"artifact"},"id":"1","jsonrpc":"2.0"}

Final status event indicating the task is complete:

data:{"result":{"taskId":"0ca889db-417e-45f5-bd85-009637754bb9","contextId":"3cd9546a-68e5-432a-b8db-7743dd6f1909","status":{"state":"completed"},"type":"status","final":true},"id":"1","jsonrpc":"2.0"}

Key Fields:

Field	Description
`taskId`	Unique identifier for the task
`contextId`	Context identifier for multi-turn conversations
`type`	Event type: `status` or `artifact`
`final`	`true` when the stream is complete
`append`	`true` indicates content should be appended to previous chunks
`lastChunk`	`true` when this is the final chunk of an artifact

Stream Handling Requirements

Events are delivered in order and must not be reordered
The stream ends when you receive a status event with "final": true
Terminal states include: completed, failed, canceled, rejected
Capture the contextId from the response for follow-up messages in multi-turn conversations

Task States

A2A tasks progress through defined lifecycle states:

State	Description
`submitted`	Task has been created and acknowledged
`working`	Task is actively being processed
`input-required`	Agent needs additional information to proceed
`completed`	Task finished successfully (terminal)
`failed`	Task encountered an error (terminal)
`canceled`	Task was canceled before completion (terminal)
`rejected`	Agent declined to perform the task (terminal)

Multi-Turn Conversations

The A2A protocol supports multi-turn conversations through the contextId field. When you send an initial message, the server generates a contextId in the response. Include this contextId in subsequent messages to continue the conversation. Initial Request:

{
  "jsonrpc": "2.0",
  "method": "message/send",
  "params": {
    "message": {
      "role": "user",
      "parts": [
        {
          "kind": "text",
          "text": "Hi, I need help with a support ticket"
        }
      ]
    }
  },
  "id": 1
}

Follow-up Request (using contextId from response):

{
  "jsonrpc": "2.0",
  "method": "message/send",
  "params": {
    "message": {
      "role": "user",
      "parts": [
        {
          "kind": "text",
          "text": "The issue is with login authentication"
        }
      ],
      "contextId": "a269e867-fe40-4588-a381-c2596aeb3557"
    }
  },
  "id": 2
}

The contextId groups related messages, enabling the agent to maintain conversational continuity across multiple interactions. When an agent requires additional input, it returns a task with input-required status—use the same contextId to provide the requested information.

Testing A2A Connections

To test your A2A integration with Elementum agents, use the official A2A Inspector tool: A2A Inspector: github.com/a2aproject/a2a-inspector The inspector allows you to:

Fetch and validate Agent Cards
Send test messages and view responses
Monitor streaming events in real-time
Debug authentication and protocol issues

Protocol Version

Elementum currently implements A2A protocol version 0.3.0 with streaming support. The examples in this documentation reflect the current implementation. For the complete A2A protocol specification, see a2a-protocol.org.

Conclusion

This guide has provided a comprehensive overview of how to create, configure, and deploy AI Agents in your platform. By following these instructions, you can leverage both internal Elementum agents and external agents from providers like Snowflake Cortex and AWS Bedrock to automate tasks, assist users, and streamline workflows. The combination of internal and external agents through the Agent Orchestration Center enables you to build sophisticated automation ecosystems that respect data boundaries while maximizing AI capabilities. The A2A protocol support enables Elementum agents to participate in broader agent ecosystems, allowing external systems to programmatically interact with your agents through a standardized interface with streaming capabilities. Always test your Agents thoroughly to ensure they meet your specific use cases, whether for L1 support or other scenarios like HR onboarding, sales assistance, or automated data analysis. For further assistance, refer to the knowledge base or contact support.

Overview

Capabilities

Agent Management

Agent Integrations

Introduction

Agent Platform

Creating and Configuring Agents

Assigning Agents to Apps

Tools

Skills

Create Record Tool

Record Search Tool

Update Record Tool

AI Search Records Tool

Run Automation Tool

Run Agent Tool

MCP Tool

Deploying Agents into Workflows

Assigning Agents to Workflows

Integrating with Microsoft Teams

Integrating with Phone Calls

External Agents via App Intelligence

External Agent Configuration

Snowflake Cortex Agents Integration

AWS Bedrock Agents Integration

Agent Discovery and Management

Technical Integration

Agent-to-Agent Protocol (A2A)

A2A Protocol Overview

Connecting to an Elementum Agent via A2A

Streaming Responses

Task States

Multi-Turn Conversations

Testing A2A Connections

Protocol Version

Conclusion

Overview

Capabilities

Agent Management

Agent Integrations

​Introduction

​Agent Platform

​Creating and Configuring Agents

​Assigning Agents to Apps

​Tools

​Skills

​Create Record Tool

​Record Search Tool

​Update Record Tool

​AI Search Records Tool

​Run Automation Tool

​Run Agent Tool

​MCP Tool

​Deploying Agents into Workflows

​Assigning Agents to Workflows

​Integrating with Microsoft Teams

​Integrating with Phone Calls

​External Agents via App Intelligence

​External Agent Configuration

​Snowflake Cortex Agents Integration

​AWS Bedrock Agents Integration

​Agent Discovery and Management

​Technical Integration

​Agent-to-Agent Protocol (A2A)

​A2A Protocol Overview

​Connecting to an Elementum Agent via A2A

​Streaming Responses

​Task States

​Multi-Turn Conversations

​Testing A2A Connections

​Protocol Version

​Conclusion

Introduction

Agent Platform

Creating and Configuring Agents

Assigning Agents to Apps

Tools

Skills

Create Record Tool

Record Search Tool

Update Record Tool

AI Search Records Tool

Run Automation Tool

Run Agent Tool

MCP Tool

Deploying Agents into Workflows

Assigning Agents to Workflows

Integrating with Microsoft Teams

Integrating with Phone Calls

External Agents via App Intelligence

External Agent Configuration

Snowflake Cortex Agents Integration

AWS Bedrock Agents Integration

Agent Discovery and Management

Technical Integration

Agent-to-Agent Protocol (A2A)

A2A Protocol Overview

Connecting to an Elementum Agent via A2A

Streaming Responses

Task States

Multi-Turn Conversations

Testing A2A Connections

Protocol Version

Conclusion