Introducing ActionKit - Integrations for AI Agents

Today, we’re announcing the launch of ActionKit, Paragon’s new product for providing 1000+ integration tools to AI Agents with a single API call.

Companies productizing AI Agents have increasingly gained mainstream adoption as foundational models and agent reasoning rapidly improve. These agentic products are now capable of automating many business functions from sales and marketing to customer support - with transformative implications on how we envision the future of work.

That future is no longer constrained by model capability. The real challenge is the fact that AI agents live in data and workflow isolation - outside of customers’ core business data and applications. For example, an AI Sales Agent is only as useful as its ability to access and update relevant sales data from CRMs, call recordings, email, and other applications.

But every 3rd-party data source and application requires a custom implementation, which makes building truly connected agents incredibly difficult to scale.

We built ActionKit to solve this exact problem.

What is ActionKit?

With ActionKit, AI Agents can dynamically use Paragon to connect to their users' third-party applications like CRMs, email, calendars, and ticketing systems, and pick from dozens of ActionKit’s supported actions within each application. This enables the AI Agents to intelligently retrieve context from or automate actions across various data sources like CRMs, email, calendars, and ticketing systems, all from a natural language prompt.

For example, an AI Agent might use ActionKit to perform actions like:

• Retrieving and updating a user’s relevant Salesforce records when automating sales outreach

• Creating tasks in a user’s Jira based on action items an agent recognizes from a meeting transcript

• Querying real-time sales reports in a user's Shopify when an agent is asked questions about online sales

• Creating a Google Docs draft to start a project based on a user prompt

How does this work? ActionKit exposes JSON Schema and OpenAPI specs for every integration action, making them discoverable for agents to select and execute based on the context of a user prompt or conversation, with the right input parameters. Here’s an example of the HUBSPOT_CREATE_RECORD_CONTACTS tool.

{
  "actions": {
    "hubspot": [{
      "type": "function",
      "function": {
        "name": "HUBSPOT_CREATE_RECORD_CONTACTS",
        "description": "Create a contact in HubSpot CRM",
        "parameters": {
          "type": "object",
          "properties": {
            "field-email": {
              "type": "string",
              "description": "Email"
            },
            "field-firstname": {
              "type": "string",
              "description": "First Name"
            },
            "field-lastname": {
              "type": "string",
              "description": "Last Name"
            },
            "field-jobtitle": {
              "type": "string",
              "description": "Job Title"
            },
            "field-company": {
              "type": "string",
              "description": "Company Name"
            },
            "field-hubspot_owner_id": {
              "type": "string",
              "description": "Contact Owner: The HubSpot user who is assigned to this contact. Use Connect Portal Workflow Settings to allow users to select an Owner. (example value: \\\\"{{settings.owner}}\\\\")"
            },
            "field-lifecyclestage": {
              "type": "string",
              "description": "Lifecycle Stage: Defaults to the user’s first Lifecycle Stage if not provided. Use Connect Portal Workflow Settings to allow users to select a Lifecycle Stage. (example value: \\\\"{{settings.lifecycleStage}}\\\\")"
            },
            "field-hs_lead_status": {
              "type": "string",
              "description": "Lead Status: Defaults to the user’s first Lead Status if not provided. Use Connect Portal Workflow Settings to allow users to select a Lead Status. (example value: \\\\"{{settings.leadStatus}}\\\\")"
            },
            "additionalFieldsJSON": {
              "type": "string",
              "description": "Additional Fields: Specify any other fields that should be updated in JSON below. Use Connect Portal Workflow Settings to allow users to select which Contact fields to update. (example value: \\\\"{\\\\n  \\\\"property_number\\\\": \\\\"17\\\\",\\\\n  \\\\"property_dropdown\\\\": \\\\"choice_b\\\\",\\\\n  \\\\"property_radio\\\\": \\\\"option_1\\\\",\\\\n  \\\\"property_string\\\\": \\\\"value\\\\",\\\\n  \\\\"property_date\\\\": \\\\"1572480000000\\\\"\\\\n}\\\\")"
            }
          },
          "required": [
            "recordType",
            "field-email"
          ],
          "additionalProperties": false,
          "$schema": "<http://json-schema.org/draft-07/schema#>"
        }
      }
    }]
  },
  "errors": []
}

ActionKit is built on the Paragon’s core integration platform, including 130+ integration connectors, the embedded Connect Portal, and fully-managed authentication. ActionKit is also LLM-agnostic, this means that with just a few lines of code, ActionKit can equip virtually any AI Agent with hundreds of production-ready integration tools that can be used with customers.

ActionKit Playground Demo

We built ActionKit Playground to help showcase ActionKit in action. To demonstrate a simple example, we can instruct our playground’s agent to act as a useful sales assistant, and prompt it to retrieve and update CRM records from Salesforce.

With the embedded Connect Portal, your users can connect and give your AI agent access to their 3rd-party apps.

Note: The Connect Portal can be white-labeled, and you can even build your own UI via our headless implementation.

Using ActionKit, our agent dynamically selects the relevant Salesforce integration actions (search record, update record) and performs them in the context of our conversation. It retrieves the relevant Salesforce contact and updates the contact fields as we requested.

We can then prompt our agent to send a message in Slack summarizing the changes it made in Salesforce. Our agent uses ActionKit again to select the relevant Slack integration action (Send message in channel).

This is just a basic example to demonstrate the capabilities that ActionKit can provide to your AI Agent - if you're interested in trying out the ActionKit Playground for yourself, get access by booking some time with us here!

The Future of Paragon for AI Integrations

ActionKit is a natural evolution of Paragon’s mission to build the connecting layer for all software. Over the last five years, we’ve developed deep connectors to many of the most popular B2B applications, with abstractions over each API that are now fine-tuned to help AI Agents easily understand and interact with the 3rd-party APIs.

We’re very excited by the many possibilities ActionKit will enable for companies building AI products. But this is just the start of our vision and what we aim to accomplish in the rapidly transitioning AI landscape. We believe that the future of work will be shaped by the mainstream adoption of generative AI in what will be the greatest industrial revolution since the internet. It is our goal to accelerate that future by providing the integration infrastructure to help support the next generation of AI products.

Starting with ActionKit, we will be expanding the Paragon platform in 2025 with several new products designed for AI companies to integrate their products with the SaaS ecosystem - to help build more powerful agents, deliver more relevant insights, automate more complex work, and ultimately solve the AI data isolation problem.

Get started with ActionKit

Read the ActionKit docs to learn more and book a demo with our team to get access! You can also sign up for a free trial here.