Skip to content

Connect ExecVision to AI Agents: Audit Call Reviews & Team Activity

Nidhi KN Nidhi KN 9 min read AI & Agents
TrutoFor teams building AI agents

Give your AI agent ExecVision tools.

Connect ExecVision to AI agents using Truto's /tools endpoint. This guide covers ExecVision API quirks, rate limit handling, multi-step agent workflows, and practical code examples for automating sales coaching.

In this guide

  1. 01Connect your ExecVision account
  2. 02Fetch Truto tools
  3. 03Bind tools to your LLM
  4. 04Implement rate limit handling

The guide

Learn how to connect ExecVision to AI agents using Truto. Fetch AI-ready tools, bind them to LangChain, and automate call audits and coaching workflows.

You want to connect ExecVision to an AI agent so your system can independently audit call reviews, extract coaching plans, score sales interactions, and track team activity. Here is exactly how to do it using Truto's /tools endpoint and SDK, bypassing the need to build and maintain a custom Mediafly/ExecVision integration from scratch.

Giving a Large Language Model (LLM) read and write access to your conversation intelligence platform is an engineering headache. You either spend weeks building, hosting, and maintaining a custom connector, or you use a managed infrastructure layer that handles the boilerplate for you. If your team uses ChatGPT, check out our guide on connecting ExecVision to ChatGPT, or if you are building on Anthropic's models, read our guide on connecting ExecVision 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 ExecVision, bind them natively to an LLM using LangChain (or frameworks like LangGraph, CrewAI, or Vercel AI SDK), and execute complex revenue operations workflows. For a deeper look at the architecture behind this approach, refer to our research on architecting AI agents and the SaaS integration bottleneck.

Why a Unified Tool Layer Matters for Agent Safety

Before writing a line of integration code, decide what layer your agent talks to. This choice determines how safe and deterministic your production system will be.

Direct API tools - mapping one agent tool directly to one raw ExecVision endpoint - look convenient in a prototype but push provider quirks directly into the LLM's context window. The model has to remember that ExecVision requires specialized search syntax, that speakers in a transcript are mapped dynamically to internal users or external CRM contacts, and that deletion requests fail ungracefully unless explicitly enabled by vendor support. Every one of those quirks is a hallucination waiting to happen.

Truto collapses these endpoints behind a standardized Proxy API layer. Your agent sees deterministic, schema-bound tools like exec_vision_calls_search and list_all_exec_vision_call_transcripts. This gives you concrete safety wins:

  1. Smaller attack surface for hallucination. The LLM only ever chooses from a stable list of function names with strict JSON schemas. Invalid arguments are rejected before they ever hit the ExecVision API.
  2. Deterministic parameter normalization. ExecVision's complex query requirements are abstracted. The agent provides standard JSON inputs, and Truto handles the translation into ExecVision's required HTTP queries.

The Engineering Reality of the ExecVision API

Building an AI agent is a straightforward exercise in prompting and state management. Giving that agent reliable access to external systems is where projects stall. If you decide to build a custom ExecVision connector, you own the entire API lifecycle.

ExecVision introduces several specific integration challenges that break standard REST assumptions. If you hardcode these interactions into your agent, you will spend your sprints writing defensive integration code instead of improving your model's reasoning.

Peculiar Search Syntax

ExecVision's search endpoint does not accept a standard JSON payload or standard query parameters. When an agent wants to find a call belonging to a specific company, it naturally attempts to send a payload like {"company": "Hewlett Packard Enterprise"}.

The API will reject this. ExecVision requires exact-match syntax where you pass exactly one field per search, and the value must be entirely lowercase with spaces replaced by plus signs. The raw query must look like truto_field_name=metadata.company and truto_field_value=hewlett+packard+enterprise. Truto's tool layer provides a clean schema to the LLM and translates the input into this strict format under the hood.

The since and last_id Pagination Trap

Most modern APIs use limit/offset or cursor-based pagination. ExecVision paginates lists (like calls or deleted calls) using a combination of a timestamp (since) and a UUID (last_id). To page through results, the caller must parse the last record in the array, extract its last modified time and ID, and pass those exactly into the next request. Forcing an LLM to manage this multi-variable state across tool calls almost guarantees infinite loops or dropped data. Truto's proxy layer handles pagination transparently.

Strict Rate Limit Execution

When deploying autonomous agents, the system will eventually hit API rate limits. ExecVision enforces rate limits on its endpoints.

A critical architectural note: Truto does not automatically retry, throttle, or absorb rate limit errors on your behalf. When the upstream ExecVision API returns an HTTP 429 Too Many Requests, Truto passes that error directly to the caller.

However, Truto normalizes the fragmented, provider-specific rate limit headers into standardized IETF draft headers: ratelimit-limit, ratelimit-remaining, and ratelimit-reset. Your agent's execution loop is responsible for reading ratelimit-reset, pausing execution, and applying backoff. This ensures your agent framework maintains absolute control over state and execution time without opaque timeouts happening in a middleware layer.

ExecVision AI Agent Tools

Truto provides a comprehensive suite of AI-ready tools for ExecVision via the /integrated-account/<id>/tools endpoint. Here are the highest-leverage tools for automating coaching and audit workflows.

Finds specific call IDs based on a single metadata field. This is the entry point for almost any targeted agent workflow, allowing the LLM to locate calls for a specific company, representative, or topic without pulling the entire database.

"Find all calls associated with the company 'Acme Corp' from the last 30 days."

2. Get Call Details (get_single_exec_vision_call_by_id)

Retrieves a single call by its UUID, returning all optional data including stats, metadata, and CRM matches. Agents use this to gain complete context on an interaction before pulling the transcript.

"Fetch the full metadata and CRM match details for the call with ID 550e8400-e29b-41d4-a716-446655440000."

3. List Call Transcripts (list_all_exec_vision_call_transcripts)

Returns the simplified transcript of a specific call. It intelligently identifies speakers, matching them to internal ExecVision users, external CRM contacts, or unknown participants, alongside the exact start and end seconds of each utterance.

"Pull the transcript for the demo call we just found, and summarize the objections raised by the EXTERNAL speaker."

4. List Call Scores (list_all_exec_vision_scores)

Retrieves scorecard answers from call reviews. It returns granular row data detailing the reviewer, the caller, the specific skills evaluated, the raw answer, and the normalized percentage score. Essential for auditing manager grading behavior.

"Get all scorecard evaluations submitted this week and identify any reps who scored below 70 percent on the 'Objection Handling' skill."

5. List Coaching Plans (list_all_exec_vision_coaching_plans)

Fetches active coaching plans, detailing the objective, the designated coach, the recipient, the status of planned meetings, and the target skills. Agents use this to cross-reference current call behavior with a rep's ongoing coaching goals.

"Pull the current coaching plan for Jane Doe and verify if her target skills align with the weaknesses found in her latest call scorecard."

6. List Call Listens (list_all_exec_vision_listens)

Returns a nightly-computed audit log of who listened to whose calls, and for how long. This is a powerful tool for agents tasked with verifying that sales managers are actually reviewing the required volume of team calls.

"Generate a report on manager call review activity. Which managers have listened to fewer than 5 calls from their direct reports this month?"

For the complete tool inventory and JSON schema definitions, view the ExecVision integration page.

Workflows in Action

AI agents excel at correlating disjointed data sets. By combining ExecVision tools, you can automate workflows that would normally take revenue operations teams hours of manual auditing.

1. Automated Scorecard and KPI Auditing

Sales enablement teams need to ensure managers are grading calls fairly and that those grades correlate with actual call content.

"Audit John Smith's calls from this week. Pull his scorecard results, then read the transcripts of his lowest-scoring calls. Tell me if the manager's feedback on 'Discovery Questions' accurately reflects the transcript."

Step-by-step execution:

  1. The agent calls list_all_exec_vision_scores filtered for John Smith to find his lowest-scoring interactions.
  2. The agent extracts the call IDs from the scorecards.
  3. The agent iterates over the IDs, calling list_all_exec_vision_call_transcripts for each.
  4. The LLM analyzes the transcripts against the scorecard criteria and generates a discrepancy report.

2. Cross-referencing Coaching Plans with Adherence

Sales directors need to know if frontline coaching is actually changing rep behavior on the phone.

"Find the active coaching plan for Sarah Jenkins. Note her target skills. Then, pull her last 3 call transcripts and determine if she is applying the new closing techniques defined in her plan."

Step-by-step execution:

  1. The agent calls list_all_exec_vision_coaching_plans to identify Sarah's active plan and target skills.
  2. The agent calls exec_vision_calls_search to locate her most recent calls.
  3. The agent uses list_all_exec_vision_call_transcripts to pull the conversational text.
  4. The agent formulates an assessment of her adherence to the coaching plan based on the transcript text.

3. Manager Activity Compliance

Revenue operations often struggles to enforce manager call review metrics.

"Check the call listening activity for all regional managers over the last 14 days. Cross-reference this with the coaching meetings they have logged. Flag any manager who is holding coaching meetings without listening to the rep's calls first."

Step-by-step execution:

  1. The agent calls list_all_exec_vision_listens to get the raw audit log of manager listening time.
  2. The agent calls list_all_exec_vision_meetings to get the log of completed coaching sessions.
  3. The LLM correlates the timestamps and user IDs, identifying instances where a meeting occurred but no prior call listening was logged.

Building Multi-Step Workflows

To build these multi-step workflows, your agent needs a framework-agnostic way to fetch Truto tools, bind them to the LLM, and execute a loop that handles tool responses and rate limits gracefully.

Below is an architecture pattern using truto-langchainjs-toolset and LangChain. This pattern is easily adaptable to LangGraph, CrewAI, or the Vercel AI SDK.

sequenceDiagram
    participant App as Your Node.js App
    participant Truto as Truto /tools API
    participant LLM as LLM (OpenAI/Anthropic)
    participant Upstream as "ExecVision API"
    
    App->>Truto: GET /integrated-account/{id}/tools
    Truto-->>App: Returns JSON Schema for Tools
    App->>LLM: .bindTools() and invoke with prompt
    LLM-->>App: ToolCall (exec_vision_calls_search)
    App->>Truto: Execute Tool (Proxy API)
    Truto->>Upstream: Translated HTTP Request
    alt Rate Limit Exceeded
        Upstream-->>Truto: HTTP 429 Too Many Requests
        Truto-->>App: HTTP 429 + ratelimit-reset header
        Note over App: App pauses execution (Backoff)
        App->>Truto: Retry Tool Execution
    end
    Upstream-->>Truto: Raw JSON Response
    Truto-->>App: Standardized Tool Response
    App->>LLM: Submit Tool Message
    LLM-->>App: Final natural language answer

Implementing the Agent Loop

Here is how you fetch the tools, bind them, and handle the execution loop, including safe backoff for HTTP 429 errors.

import { ChatOpenAI } from "@langchain/openai";
import { TrutoToolManager } from "truto-langchainjs-toolset";
import { HumanMessage, ToolMessage } from "@langchain/core/messages";
 
async function runExecVisionAudit(prompt: string) {
  // 1. Initialize the LLM
  const llm = new ChatOpenAI({ 
    modelName: "gpt-4o",
    temperature: 0 
  });
 
  // 2. Fetch tools from Truto for the connected ExecVision account
  const toolManager = new TrutoToolManager({
    trutoApiKey: process.env.TRUTO_API_KEY,
    integratedAccountId: process.env.EXECVISION_ACCOUNT_ID,
  });
 
  const tools = await toolManager.getTools();
  const llmWithTools = llm.bindTools(tools);
 
  // 3. Initialize message state
  const messages = [new HumanMessage(prompt)];
 
  // 4. Run the Agent Loop
  while (true) {
    const aiMessage = await llmWithTools.invoke(messages);
    messages.push(aiMessage);
 
    // Break if the LLM is done and provides a final answer
    if (!aiMessage.tool_calls || aiMessage.tool_calls.length === 0) {
      console.log("Agent Output:", aiMessage.content);
      break;
    }
 
    // Execute each requested tool
    for (const toolCall of aiMessage.tool_calls) {
      console.log(`Executing tool: ${toolCall.name}`);
      const tool = tools.find((t) => t.name === toolCall.name);
      
      let toolResult;
      let retries = 3;
 
      while (retries > 0) {
        try {
          toolResult = await tool.invoke(toolCall.args);
          break; // Success, exit retry loop
        } catch (error: any) {
          // 5. Handle standard IETF Rate Limits passed through by Truto
          if (error?.status === 429) {
            const resetTime = error.headers?.['ratelimit-reset'];
            const waitMs = resetTime ? (parseInt(resetTime) * 1000) - Date.now() : 2000;
            
            console.warn(`Rate limited. Backing off for ${waitMs}ms...`);
            await new Promise((resolve) => setTimeout(resolve, Math.max(waitMs, 1000)));
            retries--;
            if (retries === 0) throw new Error("Rate limit retries exhausted");
          } else {
            throw error; // Throw non-rate-limit errors
          }
        }
      }
 
      // Append the successful tool result to context
      messages.push(new ToolMessage({
        tool_call_id: toolCall.id,
        content: JSON.stringify(toolResult)
      }));
    }
  }
}
 
// Execute the agent
runExecVisionAudit("Find the latest call for Acme Corp and tell me if the manager has reviewed it yet based on the scorecard data.");

This pattern guarantees that your agent will reliably fetch ExecVision data, respect the provider's specific API limits, and maintain a clean context window free of HTTP plumbing code.

Strategic Architecture for Autonomous Auditing

Connecting ExecVision to AI agents is not a data extraction problem; it is a schema management and state orchestration problem. By abstracting the ExecVision API behind Truto's /tools endpoint, you remove the burden of pagination formatting, exact-match search syntax, and unpredictable edge cases from your LLM's context.

Your agent interacts exclusively with standard JSON schemas, while your application code retains absolute control over rate limit backoff and execution state. This allows your engineering team to focus on refining agent prompts and workflow logic, rather than maintaining fragile, point-to-point CRM integrations.

Two ways to put ExecVision to work

Truto

For product teams

Give your agent ExecVision tools

Your customers connect their own ExecVision accounts. Your product gets one API and MCP tools for ExecVision, through Truto.

FAQ

Can AI agents access ExecVision call transcripts directly?
Yes. By using Truto's `list_all_exec_vision_call_transcripts` tool, an AI agent can retrieve simplified transcripts with speaker identifications (INTERNAL, EXTERNAL) and timestamped utterances, formatted cleanly as JSON.
How does Truto handle ExecVision API rate limits?
Truto does not automatically retry or absorb rate limit errors. If the ExecVision API returns an HTTP 429 error, Truto passes the error to the caller and normalizes the headers into standardized IETF draft headers (`ratelimit-limit`, `ratelimit-remaining`, `ratelimit-reset`). The caller's agent loop must implement backoff.
Do I need to manage ExecVision API pagination in my agent?
No. The ExecVision API natively uses a complex `since` and `last_id` pagination scheme, but Truto's Proxy API abstracts this away. The tools provided to your agent handle the pagination automatically, allowing the LLM to simply request data without maintaining cursor state.
Can I customize the tool descriptions provided to the LLM?
Yes. Truto provides default descriptions for all ExecVision tools, but you can edit these descriptions in the Truto interface to better guide your specific LLM's behavior. Updates reflect in the `/tools` endpoint in real-time.
ExecVision ExecVisionAI agent tools Get a sandbox

More from our Blog