Agentic Actions Across Integrations

When building an AI agent application, you’ll need to give it the ability to perform read, write, and update operations in your customers’ 3rd-party applications like CRMs, calendar apps, ticketing platforms, etc.

Paragon makes it easy to equip your AI agents with 3rd-party actions with two main methods:

1. ActionKit: a set of APIs designed to slot in as function tools for your AI agent that perform 3rd-party actions

2. Workflows: a flexible approach for more complex, asynchronous jobs that users can define in Paragon’s workflow builder

ActionKit

ActionKit is our first-class solution for enabling 3rd-party actions to your agent. With a single GET action call , the ActionKit API exposes thousands of actions for popular integration providers like Google Drive, Calendar, Slack, Salesforce, and many more (search for our available 3rd-party providers (here)[https://www.useparagon.com/integrations]).

These actions can be given to your agents as tools, giving your agent the capability to perform actions like:

• Querying data from a CRM

• Sending messages via Slack and teams

• Updating tickets in platforms like Jira and Zendesk

What ActionKit looks like:

ActionKit is designed to be easy to work with for AI implementations. In your implementation, you can give the tool data returned from the ActionKit API directly to your agent in the form of function tools.

import { generateText } from 'ai';
import { openai } from '@ai-sdk/openai';

const actions = await fetch("<https://actionkit.useparagon.com/projects/><Project ID>/actions", {
	method: "GET",
	headers: {
		Authorization: 'Bearer ' + PARAGON_USER_TOKEN
	}
});

await generateText({
	model: openai('gpt-4o'),
	tools: Object.values(await actions.json()).flat(),
	toolChoice: 'auto',
	temperature: 0,
	system: 'You are a helpful assistant. Be as concise as possible.',
	prompt: 'Help me create a new task in Jira.'
});

This example is using Vercel’s AI SDK, but you can use ActionKit with any framework you prefer. ActionKit is LLM and framework agnostic where you can pass ActionKit into any LLM that supports function tools.

Once the ActionKit tools are loaded, your AI agent can perform actions in 3rd-party integration providers similar to this:

In this example, our agent was able to call the SALESFORCE_WRITE_SOQL_QUERY with the SLACK_LIST_MEMBERS tool to send Salesforce data via Slack with one message to our agent.

Workflows

While ActionKit is Paragon’s first-class solution natively built for function tools and quick, synchronous actions perfect for fast responses, workflows may be better for use cases including:

1. large asynchronous tasks that may require long-running jobs like pulling and processing data from a users’ entire CRM

   1. See our [data ingestion use case] or [permissions ingestion use case]

2. Building pre-defined complex flows that you want to be repeatedly called

For example, if you need to get a user’s Google calendar availability with specific formatting and behavior, your AI agent can use a workflow like this one to calculate the availability based on the existing events that the Google Calendar API returns (you can also achieve something similar with ActionKit with some creativity and function tool chaining).

In your code, you can create a function tool for your agent where you can specify workflow description and parameters to trigger the workflow via POST request.

const getSdrSchedule = FunctionTool.from(
      async ({ input }: {input: string}) => {
        console.log("Getting SDR Calendar");
        const response = await getGoogleCalendarAvailability(signJwt(userId));
        console.log(response);
        if (response.busy) {
          return response.busy;
        }
        return "Calendar could not be pulled";
      },
      {
        name: "getSdrSchedule",
        description: "Use this function when a user asks to schedule a meeting with the SDR. This function returns when " +
            "the SDR is busy and UNABLE to meet." +
            "Times are provided in UTC format. Use the convertUtcDatetimeToPstDatetime tool to convert UTC datetimes to" +
            "PST before returning results.",
        parameters: {
          type: "object",
          properties: {
            dummy: {
              type: "string",
              description: "dummy",
            },
          },
          required: [],
        },
      },
    );

export async function getGoogleCalendarAvailability(jwt: string) {
    return await fetch(process.env.GET_GOOGLE_CALENDAR_EVENTS_ENDPOINT ?? "", {
        method: "POST",
        headers: {
            "Content-Type": "application/json",
            Authorization: "bearer " + jwt,
        },
    })
        .then((response) => response.json())
        .catch((error) =>
            console.log("Error getting Google Calendar events: " + error)
        );
}

By enabling your AI agent with both workflows and ActionKit tools, you can create interactions like this one where your AI application can truly be assistant-like.

Wrapping Up

Paragon provides multiple ways AI applications can perform agentic actions in a 3rd-party platform.

1. Use ActionKit for an API specifically built for agents that can be plugged right in as function tools

2. Use workflows for complex defined tasks and longer-running asynchronous jobs

Our team has built solutions that empower our customers to build out integrations for their AI use cases. To learn more about how Paragon can enable your AI application to perform actions across integrations and our exciting new AI-focused features, book a demo to schedule some time with our team.