Connect Follow Up Boss to AI Agents: Automate Events & Lead Flows

You want to connect Follow Up Boss to an AI agent so your system can independently triage leads, log communication events, trigger action plans, and progress deals based on conversational context. Here is exactly how to do it using Truto's /tools endpoint and SDK, bypassing the need to build and maintain a custom Follow Up Boss integration from scratch.

Real estate CRMs and revenue operations platforms run on strict workflows. Giving a Large Language Model (LLM) read and write access to your Follow Up Boss instance means the model cannot afford to hallucinate payload structures or guess at duplicate resolution. If your team relies on standard chatbot interfaces, check out our guide on connecting Follow Up Boss to ChatGPT, or if you are building on Anthropic's models, read our guide on connecting Follow Up Boss 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 Follow Up Boss, bind them natively to an LLM using frameworks like LangChain, LangGraph, CrewAI, or the Vercel AI SDK, and execute complex real estate lead workflows. For a broader look at this design pattern across the SaaS ecosystem, read our deep dive on Architecting AI Agents: LangGraph, LangChain, and the SaaS Integration Bottleneck.

Why a Unified Tool Layer Matters for Agent Safety

Before you start writing API requests, you must decide how your AI agent will interface with external systems. This architectural decision determines the stability of your production environment.

Building direct point-to-point tool calls - where you write a custom Node.js or Python function for every Follow Up Boss endpoint - pushes vendor-specific API quirks directly into the LLM's context window. The model has to "know" that creating a lead in Follow Up Boss requires a different endpoint than triggering a lead automation, or that updating a phone number requires passing the entire array of phone numbers rather than just the new one. Every quirk is an opportunity for the model to hallucinate a bad payload.

A unified tool layer abstracts these endpoints into stable, normalized JSON schemas. When Truto proxies the Follow Up Boss API, it provides a /tools endpoint that exposes these resources as structured, LLM-ready functions.

This provides immediate architectural advantages:

1. Deterministic input validation: Every tool has a strict JSON schema. Invalid arguments generated by the LLM are rejected before they ever hit Follow Up Boss, allowing the agent framework to catch the error and prompt the LLM to self-correct.
2. Reduced prompt bloat: You do not need to paste Follow Up Boss API documentation into your system prompt. The agent discovers the tools, their parameters, and their descriptions dynamically at runtime.
3. Framework agnosticism: Because the tools are served via a standard API, you can bind them to any agent framework that supports OpenAI-compatible function calling.

The Engineering Reality of the Follow Up Boss API

Giving an LLM access to external data seems straightforward until you hit the reality of a mature, domain-specific API. Follow Up Boss has specific integration challenges that break standard REST assumptions. If you hardcode these interactions into your agent, your engineering cycles will be consumed by writing defensive data transformation logic.

The "Event vs. Person" Lead Flow Trap

In standard CRMs, to add a lead, you call a POST /contacts or POST /leads endpoint. Follow Up Boss has a POST /v1/people endpoint, so an LLM will naturally want to use it.

However, in Follow Up Boss, creating a person manually via the people endpoint does not run lead automations or action plans. If your AI agent is triaging a new inbound prospect, calling POST /v1/people leaves the lead sitting dormant. The correct engineering pattern in Follow Up Boss is to call POST /v1/events to send a lead event. The system will then de-duplicate the contact, create or update the person record, trigger the appropriate lead flow, and return the person record (not the event record) with a 200 or 201 status. An AI agent needs precise tool descriptions to understand this distinction, otherwise it will silently fail your marketing workflows.

Destructive Array Updates

Follow Up Boss handles contact details (emails, phones, addresses) and tags as arrays on the person object. When updating a person via PUT /v1/people/:id, sending a new phones array overwrites the existing array entirely. If a person has three phone numbers, and your AI agent only passes the single new mobile number it collected, the other two numbers are deleted.

To safely update a person, an agent must either fetch the current record, append the new data to the array in memory, and send the full array back, or the system must heavily utilize the mergeTags=true flag.

Strict Rate Limiting and Aggressive Backoff

Follow Up Boss enforces a 24-hour rolling rate limit for registered systems, alongside short-term burst limits. When an agent enters a tight execution loop - for instance, bulk-updating deals or iterating through unclaimed leads - it will inevitably hit a 429 Too Many Requests response.

It is a critical architectural requirement to handle this explicitly. Truto does not retry, throttle, or apply backoff on rate limit errors. When the upstream Follow Up Boss API returns an HTTP 429, Truto immediately passes that error back to your caller. However, Truto normalizes the upstream rate limit information into standardized IETF headers: ratelimit-limit, ratelimit-remaining, and ratelimit-reset.

Your agent framework or HTTP client is strictly responsible for inspecting these headers and pausing execution until the ratelimit-reset timestamp. Do not rely on your agent to "absorb" 429s without explicit backoff logic; the LLM will just rapidly retry the failed tool call and exhaust your retry budget.

High-Leverage Follow Up Boss Agent Tools

Rather than exposing raw HTTP methods, Truto provides customized proxy tools for Follow Up Boss. By connecting a Follow Up Boss account and querying the GET https://api.truto.one/integrated-account/<id>/tools endpoint, your agent gains access to operations specifically tuned for revenue operations.

Here are the hero tools that unlock autonomous workflows.

follow_up_boss_people_search

Before creating a new record or firing an event, an agent must check if the person already exists to avoid corrupting lead routing. This tool checks existence by email address or phone number and returns the assignment data (assignedTo) if found.

"Check if a lead with the email example@domain.com exists in Follow Up Boss. If they do, tell me who they are assigned to."

create_a_follow_up_boss_event

This is the workhorse tool for inbound AI workflows. It sends a lead or lead event to Follow Up Boss, handles de-duplication automatically, creates or updates the contact, and triggers configured Action Plans. It returns the lead record containing the firstName, lastName, and id.

"A new lead named Sarah Connor just inquired about 123 Main St. Log this as a property inquiry event so she gets added to the standard buyer lead flow."

update_a_follow_up_boss_person_by_id

Used to enrich existing lead profiles based on conversational data. It returns the updated person record. Agents must be instructed to handle array data (like tags or phones) carefully to avoid destructive overwrites, often requiring a read-before-write pattern.

"Update person ID 45892 to change their stage to 'Hot Prospect' and ensure the tag 'AI-Qualified' is merged into their profile."

create_a_follow_up_boss_text_message

When your AI agent uses an external unified communications API (like Twilio or Bland) to text a prospect, that interaction must be logged in the CRM. This tool creates a record of an externally sent text message in Follow Up Boss. It logs the message only - it does not actually dispatch an SMS through Follow Up Boss.

"Log an outbound text message to person ID 1045. The message was 'Are you still looking to buy in Austin this quarter?' sent from my virtual number."

create_a_follow_up_boss_task

Agents excel at taking asynchronous action. When a lead requires human intervention, the agent uses this tool to create a task assigned to a specific user, complete with a due date and task type.

"Create a task for the assigned agent on person ID 8831 to call them tomorrow morning. They asked for a detailed breakdown of local property taxes."

update_a_follow_up_boss_deal_by_id

Deals represent pipeline revenue. As the agent extracts buying intent from a conversation, it can update the associated deal's numeric ID to move the pipeline stage, adjust the price, or change the status to pending or closed.

"The client just confirmed they are signing the counter-offer for deal ID 992. Move the deal to the 'Under Contract' stage."

For the complete inventory of available Follow Up Boss tools, including endpoints for smart lists, ponds, appointments, and webhooks, view the Follow Up Boss integration page.

Workflows in Action

Once these tools are bound to an agent, you can orchestrate complex, multi-step real estate operations. Here are two concrete examples of autonomous workflows.

Scenario 1: AI Inside Sales Agent (ISA) Triage

An inbound SMS comes in from a web form. Your AI agent is tasked with qualifying the lead and routing it appropriately.

"A user texted in from 555-0199 saying they want to view the property at 404 Elm St. Find out if they are in our system. If not, log them as a new lead event so they get the auto-responder, then create a task for the primary agent to call them today."

Execution Steps:

1. Agent Tool Call: follow_up_boss_people_search with { "phone": "555-0199" }.
2. Result: Truto returns a 404/not found status. The agent reasons it must create the lead.
3. Agent Tool Call: create_a_follow_up_boss_event passing the phone number, message context, and source data.
4. Result: Truto successfully proxies the event, Follow Up Boss triggers the Action Plan, and Truto returns the new person record containing id: 15422 and assignedUserId: 44.
5. Agent Tool Call: create_a_follow_up_boss_task using personId: 15422 and assignedUserId: 44 with a due date of today.
6. User Output: "I searched for the number and found no existing record. I logged a new lead event which created person ID 15422, and I have assigned a follow-up task to the owner."

Scenario 2: Deal Progression via Email Parsing

An agent monitors a shared inbox. A title company emails confirming a closing date has been scheduled.

"The title company just confirmed the closing for deal ID 8112 is set for next Tuesday. Update the deal status to 'Pending', and add a note to the primary contact explaining that closing is scheduled."

Execution Steps:

1. Agent Tool Call: get_single_follow_up_boss_deal_by_id passing { "id": 8112 } to retrieve the associated peopleIds.
2. Result: Truto returns the deal object containing the linked person ID.
3. Agent Tool Call: update_a_follow_up_boss_deal_by_id setting stageId to the ID representing 'Pending'.
4. Agent Tool Call: create_a_follow_up_boss_note using the retrieved person ID, formatting the email summary into the note body.
5. User Output: "Deal 8112 has been updated to the Pending stage, and I have added a note to the primary contact's timeline regarding the closing date."

Building Multi-Step Workflows

To build these workflows in production, you must implement an agent loop that fetches the tools dynamically and explicitly handles the engineering constraints - specifically, rate limit headers.

Because Truto exposes tools via a standardized endpoint, you can use frameworks like LangChain.js to auto-generate the tool schemas and bind them to your model.

sequenceDiagram
    participant App as Your App (LangChain)
    participant Truto as Truto Proxy
    participant FUB as Follow Up Boss API

    App->>Truto: GET /integrated-account/<id>/tools
    Truto-->>App: Returns JSON Schemas for FUB endpoints
    Note over App: App binds schemas<br>to LLM (e.g., GPT-4o)
    App->>App: User Prompt: "Add a lead..."
    App->>Truto: POST /proxy/followupboss (execute tool)
    Truto->>FUB: POST /v1/events
    alt Rate Limit Exceeded
        FUB-->>Truto: 429 Too Many Requests
        Truto-->>App: 429 with ratelimit-reset header
        Note over App: App pauses execution<br>until reset timestamp
        App->>Truto: Retry POST /proxy/followupboss
        Truto->>FUB: POST /v1/events
    end
    FUB-->>Truto: 200 OK (Person Record)
    Truto-->>App: Tool Execution Result
    Note over App: LLM generates final<br>natural language response

Here is how you implement this architecture in TypeScript using the truto-langchainjs-toolset. Notice the explicit try-catch block designed to catch upstream 429 errors and read the standardized ratelimit-reset header.

import { ChatOpenAI } from "@langchain/openai";
import { AgentExecutor, createToolCallingAgent } from "langchain/agents";
import { ChatPromptTemplate } from "@langchain/core/prompts";
import { TrutoToolManager } from "truto-langchainjs-toolset";
 
async function runFollowUpBossAgent(prompt: string, accountId: string) {
  // 1. Initialize the Truto Tool Manager
  const toolManager = new TrutoToolManager({
    trutoApiKey: process.env.TRUTO_API_KEY,
  });
 
  // 2. Fetch Follow Up Boss tools for the specific integrated account
  // Using the methods filter to only grab standard and custom operations
  const tools = await toolManager.getTools(accountId, { methods: ["standard", "custom"] });
 
  // 3. Initialize the LLM and bind the dynamically fetched tools
  const llm = new ChatOpenAI({ modelName: "gpt-4o", temperature: 0 });
  
  const promptTemplate = ChatPromptTemplate.fromMessages([
    ["system", "You are an elite Real Estate ISA agent. You manage Follow Up Boss data. Always search for a user before creating them. If creating a user, use the events tool to trigger automations."],
    ["human", "{input}"],
    ["placeholder", "{agent_scratchpad}"],
  ]);
 
  const agent = createToolCallingAgent({ llm, tools, prompt: promptTemplate });
  const executor = new AgentExecutor({ agent, tools, maxIterations: 5 });
 
  // 4. Execute the workflow with explicit rate limit handling
  try {
    const result = await executor.invoke({ input: prompt });
    console.log("Agent finished:", result.output);
  } catch (error: any) {
    // Truto passes the 429 error directly from Follow Up Boss.
    // We must inspect the normalized headers and apply backoff.
    if (error.response && error.response.status === 429) {
      const resetTime = error.response.headers['ratelimit-reset'];
      console.warn(`Rate limit hit. Follow Up Boss requires pausing until timestamp: ${resetTime}.`);
      // Implementation of delay/queueing logic goes here
    } else {
      console.error("Workflow failed:", error);
    }
  }
}
 
runFollowUpBossAgent(
  "Check if 555-0199 exists. If not, log a property inquiry event and assign a task.",
  "your-fub-integrated-account-id"
);

By leveraging the /tools endpoint, you remove the burden of writing manual API wrapper functions, handling OAuth token lifecycles, and managing schema translation. The LLM interfaces with a clean, strict boundary, and your application handles the hard engineering constraints like rate limiting gracefully.

Stop wasting engineering sprints building and maintaining point-to-point API connectors. Unify your agent tools with Truto and focus on shipping better autonomous workflows.