Connect Acquire to AI Agents: Automate Support, SMS, and Bot Workflows

You want to connect Acquire to an AI agent so your system can independently manage omnichannel support queues, trigger SMS dispatches, analyze chatbot conversations, and curate knowledge base articles based on historical context. Here is exactly how to do it using Truto's /tools endpoint and SDK, bypassing the need to hand-code complex API wrappers for every messaging channel.

Giving a Large Language Model (LLM) read and write access to your Acquire instance is an engineering headache. You either spend weeks building, hosting, and maintaining a custom connector that understands the difference between thread IDs, timeline IDs, and active case states, or you use a managed infrastructure layer that handles the boilerplate for you. If your team uses ChatGPT, check out our guide on connecting Acquire to ChatGPT, or if you are building on Anthropic's models, read our guide on connecting Acquire to Claude. For developers building custom autonomous workflows, you need a programmatic way to fetch these tools and bind them to your agent framework.

This guide breaks down exactly how to fetch AI-ready tools for Acquire, bind them natively to an LLM using LangChain (or any framework like LangGraph, CrewAI, or Vercel AI SDK), and execute complex customer support workflows. For a deeper look at the architecture behind this approach, refer to our research on architecting AI agents and the SaaS integration bottleneck.

The Engineering Reality of Custom Acquire Connectors

Building AI agents is easy. Connecting them to external SaaS APIs is hard. Giving an LLM access to external data sounds simple in a prototype. You write a Node.js function that makes a fetch request and wrap it in an @tool decorator. In production, this approach collapses entirely, especially with a platform as complex as Acquire.

If you decide to build the integration yourself, you own the entire API lifecycle. Acquire's API introduces several highly specific integration challenges that break standard LLM assumptions.

The Omnichannel State Machine Trap

Acquire is not a simple CRUD database. It is a real-time omnichannel platform. When an agent needs to send a message to a user, standard REST conventions fail. The agent cannot just POST /messages with a text string. Acquire enforces a strict state machine: you can only send messages to active cases. Furthermore, a message payload requires a contactId, a caseId, and potentially a threadId depending on the channel.

If you hand-code this integration, you have to write complex prompts to teach the LLM the exact lifecycle of an Acquire case. When the LLM inevitably hallucinates and tries to push an SMS message to a closed case without a timelineId, the API will reject it, and your agent loop will crash.

Destructive Operations and Irreversible Merges

AI agents are prone to taking the most direct path to a goal. In Acquire, managing contact records often involves the acquire_contacts_merge endpoint, which combines secondary contacts onto a primary one. This operation is permanent and cannot be reverted. Handing an LLM direct, schema-less access to an endpoint that irreversibly destroys data is a critical security and operational risk. You need a layer that validates the shape of the data and enforces strict schemas before the payload ever reaches the vendor.

Bot Configuration Quirks

Acquire allows you to manage its internal Conversational Bots via API. However, the logic for publishing QnA pairs is idiosyncratic. Pushing a question to suggestions (acquire_bot_qna_push_to_suggestions) will merge it into existing groups if a similar question exists, while the publish endpoint simply toggles states (drafts become published, published become drafts). A naive LLM will get caught in an infinite loop trying to explicitly set a "draft" state on a question that is already a draft, accidentally publishing it instead.

By routing your agent through Truto's /tools API, your agent interacts with a standardized, deterministic proxy layer. Every tool has a strict JSON schema. Invalid arguments are rejected before they hit Acquire, meaning a broken tool call fails fast instead of corrupting your CRM state.

Hero Tools for Acquire AI Agents

Truto provides a comprehensive suite of pre-configured tools for Acquire. Instead of building bespoke API calls, you dynamically load these definitions into your agent's context. Here are the highest-leverage tools available for automating support and messaging workflows.

1. List All Acquire Cases (list_all_acquire_cases)

Retrieves a filtered list of customer support cases. This is the primary discovery tool for an agent to determine what issues need attention. It supports condition-based filtering and relation expansion, meaning the agent can pull cases, users, and timeline metadata in a single call.

"Find all active support cases in the billing queue that have been pending for more than 24 hours and expand the contact relations so I can see who submitted them."

2. Create an Acquire Message (create_a_acquire_message)

Sends a standard chat message to an active conversation. The agent must provide a contactId, a caseId, and a specific message object. This tool will automatically fail gracefully if the LLM attempts to inject a message into a closed case.

"Send a chat message to contact 89342 on case 1102 saying that we have successfully processed their refund and the funds should appear in 3-5 business days."

3. Create an Acquire SMS (acquire_messages_create_sms)

Dispatches an SMS message. Because SMS relies on mobile carrier networks, it requires a higher degree of strictness. The agent must map the threadId and timelineId appropriately. This is incredibly powerful for urgent escalations.

"The database cluster just went down. Find the active support thread for our enterprise client ID 440, get the timelineId, and send them an SMS notifying them of the ongoing incident."

4. Merge Acquire Contacts (acquire_contacts_merge)

Merges two or more duplicate contacts in Acquire. The tool requires a primary merge_id and an array of sourceIds to consume. Because this is a destructive action, we recommend coupling this tool with a human-in-the-loop approval step in your agent framework.

"I found three contact records for John Doe. Keep ID 992 as the primary record and merge source IDs 881 and 882 into it."

5. Chat Overview Analytics (acquire_analytics_chat_chat_overview)

Fetches high-level chat analytics, including hourly time-series data and period-over-period summary metrics. This allows AI agents to act as data analysts, summarizing support performance without requiring a human to log into a dashboard.

"Pull the chat overview analytics for the last 7 days and summarize our average handle time compared to the previous period. Are we getting slower?"

6. Push Bot QnA to Suggestions (acquire_bot_qna_push_to_suggestions)

Allows an AI agent to train Acquire's native Conversational Bot. If an AI agent resolves a novel ticket, it can use this tool to dynamically generate a new QnA pair and push it into the bot's suggestion queue in draft status.

"Take the resolution steps we just used to fix the SSO login issue, format it as a QnA pair, and push it to the IT Support bot's suggestion queue for review."

To view the complete inventory of available proxy APIs and JSON schemas for this integration, visit the Acquire integration page.

Workflows in Action

Connecting tools to an LLM is only the first step. The real value comes from orchestrating autonomous, multi-step workflows. Here are three concrete ways engineering and operations teams are utilizing Acquire AI agents in production.

Use Case 1: Autonomous VIP Support Triage & SMS Escalation

Support operations teams often struggle to prioritize high-value customers during an incident. An AI agent can continuously monitor the queue and escalate automatically.

"Check the support queue for any new cases from users tagged as 'Enterprise'. If they have been waiting more than 15 minutes, assign a senior agent and send the customer an SMS letting them know we are looking into it."

Execution Steps:

1. Agent calls list_all_acquire_cases filtering by the Enterprise tag and a waitTime threshold.
2. Agent calls acquire_cases_invite_agent to pull a senior engineer into the chat session.
3. Agent calls acquire_messages_create_sms using the relevant thread/timeline IDs to dispatch the apology and status update.

Result: The customer feels immediately prioritized via their mobile device, and the support SLA is preserved without human triage intervention.

Use Case 2: Self-Learning Bot QnA Generation

Knowledge Managers spend hours reading closed tickets to write FAQ articles. An AI agent can run in the background, analyzing resolved cases and automatically building bot training data.

"Review all cases closed today. Identify any questions that were asked more than three times. Draft a QnA pair for the most common issue and push it to the bot suggestions."

Execution Steps:

1. Agent calls list_all_acquire_cases with closingState set to closed and a date filter for today.
2. Agent calls list_all_acquire_messages for the identified cases to read the transcripts.
3. The LLM processes the transcripts internally to identify the recurring question and the accepted answer.
4. Agent calls acquire_bot_qna_push_to_suggestions to queue the new knowledge for human review.

Result: The support team's internal knowledge base and conversational bot get smarter every day with zero manual data entry.

Use Case 3: Contact Deduplication with Confidence Scoring

Data hygiene is a massive problem in scaling CRMs. An agent can be scheduled to clean up duplicate records programmatically.

"Search for contacts with matching email domains but slightly different name spellings. If you are 99% confident they are the same person, merge them."

Execution Steps:

1. Agent calls list_all_acquire_contacts pulling the latest batch of users.
2. The LLM executes a string similarity check on names and domains.
3. If confidence is high, the agent calls acquire_contacts_merge, passing the older ID as the primary and the newer ID as the source.

Result: The CRM remains clean, preventing sales and support reps from losing context across duplicate threads.

Building Multi-Step Workflows

To build these multi-step workflows, you need to bind Truto's tools to an agent framework. The following architecture demonstrates how an AI agent requests tools, executes actions, and manages state.

flowchart TD
    A["AI Agent (LangGraph / CrewAI)"] -->|"Requests Tools"| B["Truto /tools API"]
    B -->|"Returns JSON Schema"| A
    A -->|"Executes Tool Call"| C["Truto Proxy API"]
    C -->|"Translates to Acquire REST"| D["Acquire Upstream API"]
    D -->|"Returns Data or 429"| C
    C -->|"Passes Response / Headers"| A

Fetching and Binding Tools

Truto exposes a /tools endpoint that returns a standardized schema for every method on every resource enabled for an integrated account. You can pass these directly into standard LLM frameworks.

Here is how you implement this in TypeScript using LangChain:

import { ChatOpenAI } from "@langchain/openai";
import { AgentExecutor, createOpenAIToolsAgent } from "langchain/agents";
import { ChatPromptTemplate } from "@langchain/core/prompts";
// Assume TrutoToolManager is an abstraction around the Truto SDK /tools endpoint
import { TrutoToolManager } from "truto-langchainjs-toolset";
 
async function runAcquireAgent() {
  // 1. Initialize the tool manager for the specific integrated account
  const truto = new TrutoToolManager({
    apiKey: process.env.TRUTO_API_KEY,
    accountId: "acct_acquire_12345" // The specific Acquire tenant ID in Truto
  });
 
  // 2. Fetch the tools dynamically (e.g., just the write methods for messaging)
  const acquireTools = await truto.getTools({ methods: ["create", "custom"] });
 
  // 3. Initialize your LLM
  const llm = new ChatOpenAI({
    modelName: "gpt-4o",
    temperature: 0,
  });
 
  // 4. Bind the tools to the model
  const prompt = ChatPromptTemplate.fromMessages([
    ["system", "You are a highly capable Support Ops Assistant for Acquire."],
    ["human", "{input}"],
    ["placeholder", "{agent_scratchpad}"],
  ]);
 
  const agent = await createOpenAIToolsAgent({
    llm,
    tools: acquireTools,
    prompt,
  });
 
  const agentExecutor = new AgentExecutor({
    agent,
    tools: acquireTools,
    maxIterations: 10,
  });
 
  // 5. Execute the autonomous loop
  const result = await agentExecutor.invoke({
    input: "Check for active VIP cases and send an SMS to the first one letting them know we are working on it.",
  });
 
  console.log(result.output);
}

Handling Rate Limits in the Agent Loop

A critical engineering reality of building autonomous agents is dealing with API quotas. AI agents can execute loops incredibly fast, easily overwhelming downstream APIs.

It is vital to understand how Truto handles rate limits: Truto does not automatically retry, throttle, or apply backoff on rate limit errors. When the upstream Acquire API returns an HTTP 429 (Too Many Requests), Truto passes that exact error directly back to the caller.

What Truto does do is normalize the upstream rate limit information into standardized IETF headers, regardless of how Acquire originally formats them:

• ratelimit-limit: The total request quota.
• ratelimit-remaining: The number of requests left in the current window.
• ratelimit-reset: The timestamp when the quota resets.

Your agent framework must be responsible for catching the 429 status, reading the ratelimit-reset header, and applying a pause or exponential backoff before continuing the execution loop. If you do not handle this at the caller level, your agent will continuously fail tool executions and hallucinate incorrect results.

sequenceDiagram
    participant Agent as AI Agent
    participant Truto as Truto Proxy
    participant Acquire as Acquire API
    
    Agent->>Truto: Call list_all_acquire_messages
    Truto->>Acquire: GET /messages
    Acquire-->>Truto: HTTP 429 (Quota Exceeded)
    Truto-->>Agent: HTTP 429 + ratelimit-reset header
    Note over Agent: Agent parses header<br>and pauses execution
    Agent->>Truto: Retry call after reset

Moving Beyond Point-to-Point Connectors

Connecting Acquire to AI agents shouldn't require your engineering team to become experts in thread states, timeline IDs, or bot publication workflows. By utilizing a proxy layer and the /tools endpoint, you abstract the integration complexity away from the model's context window.

The agent only sees clean, deterministic JSON schemas for exact functions like acquire_messages_create_sms. Invalid requests are rejected safely, rate limit headers are standardized for predictable backoff, and your development team can focus on orchestrating complex, revenue-generating workflows instead of maintaining integration code.