---
title: "Connect 15Five to AI Agents: Manage Users, Groups, and Vacations"
slug: connect-15five-to-ai-agents-manage-users-groups-and-vacations
date: 2026-10-31
author: Nidhi KN
categories: ["AI & Agents"]
excerpt: "Learn how to connect 15Five to AI agents using Truto's /tools endpoint. Fetch AI-ready tools programmatically and automate OKRs, reviews, and HR workflows."
tldr: "Connect 15Five to AI agents natively using Truto's SDK. This guide shows how to fetch 15Five tools, handle dynamic API schemas, manage rate limits, and build autonomous HR workflows."
canonical: https://truto.one/blog/connect-15five-to-ai-agents-manage-users-groups-and-vacations/
---

# Connect 15Five to AI Agents: Manage Users, Groups, and Vacations


You want to connect 15Five to an AI agent so your system can [autonomously update Key Results](https://truto.one/connect-15five-to-claude-sync-okrs-key-results-and-priorities/), [generate performance review summaries](https://truto.one/connect-15five-to-chatgpt-run-performance-reviews-and-check-ins/), manage out-of-office schedules, and distribute High Fives based on external triggers. Here is exactly how to do it using Truto's `/tools` endpoint and SDK, bypassing the need to build and maintain a custom 15Five integration from scratch.

Giving a Large Language Model (LLM) read and write access to your HR and performance management system is a complex engineering challenge. You either spend sprints writing defensive API wrappers, handling dynamic field schemas, and managing rate limits, or you use a managed infrastructure layer that handles the boilerplate for you. If your team uses ChatGPT, check out our guide on [connecting 15Five to ChatGPT](https://truto.one/connect-15five-to-chatgpt-run-performance-reviews-and-check-ins/), or if you are building on Anthropic's models, read our guide on [connecting 15Five to Claude](https://truto.one/connect-15five-to-claude-sync-okrs-key-results-and-priorities/). For developers building custom autonomous workflows, you need a programmatic way to fetch these tools and bind them directly to your agent framework.

This guide breaks down exactly how to fetch AI-ready tools for 15Five, bind them natively to an LLM using frameworks like [LangChain, LangGraph](https://truto.one/architecting-ai-agents-langgraph-langchain-and-the-saas-integration-bottleneck/), CrewAI, or the Vercel AI SDK, and execute complex HR automation workflows. For a deeper look at the architecture behind this approach, refer to our research on [architecting AI agents and the SaaS integration bottleneck](https://truto.one/architecting-ai-agents-langgraph-langchain-and-the-saas-integration-bottleneck/).

## The Engineering Reality of the 15Five API

Giving an LLM access to external HR data sounds straightforward in a prototype. You write a Node.js function that makes a fetch request and wrap it in an `@tool` decorator. In production against complex enterprise systems, this approach quickly breaks down.

15Five's API introduces several specific integration challenges that break standard REST assumptions. If you hardcode these interactions into your agent, you will spend your time writing integration patches instead of improving your model's reasoning capabilities.

### The UI Privacy Bypass Trap

One of the most critical quirks of the 15Five API is how it handles data visibility. In the 15Five user interface, Objectives and Key Results (OKRs) have granular privacy settings - some are public to the company, some are restricted to specific departments, and some are visible only to a user and their direct manager. 

However, the 15Five API does not inherently respect these UI-level privacy filters if you are using an admin-level or company-wide API key. The API will happily return all objectives, including those hidden by privacy settings in the UI. If you expose raw read endpoints to an LLM without wrapping them in strict access controls or filtering logic, your agent might accidentally hallucinate or leak highly sensitive executive OKRs to unauthorized users. Truto's Proxy API layer allows you to define exactly which resources the agent can see, preventing broad data exposure.

### Dynamic Attribute Shapes

Standard LLMs are trained to expect flat, predictable JSON objects. The 15Five API frequently relies on highly dynamic `attributes` payloads where the fields depend entirely on how the customer configured their account. 

For example, when querying the `list_all_15_five_group_types` or pulling Review Cycles, the data structure inside the attributes block changes based on the group's configured type or the specific review template. If your agent is hardcoded to expect `{ "department_name": "Engineering" }`, it will crash when a customer configures their groups using `{ "division_label": "Eng" }`. 

### Feature Flags and Hidden Endpoints

Some high-leverage 15Five endpoints are hidden behind feature flags. For instance, the bulk 1-on-1 export functionality requires contacting 15Five support to enable it on the account before the API will accept the request. If you give an LLM raw access to this endpoint on an unflagged account, the resulting undocumented error structures will confuse the model, leading to retry loops or broken reasoning chains. 

## Fetching 15Five Tools Programmatically

To prevent the LLM from hallucinating 15Five-specific API quirks, you must present the API as a set of strictly defined, schema-bound tools.

Every integration on Truto is essentially a comprehensive JSON object that represents how the underlying product's API behaves. Integrations have `Resources` (which map to the endpoints on 15Five's API) and `Methods` defined on them (like List, Get, Create, Update, Delete, or custom actions). 

These Methods serve as Proxy APIs. Truto handles the authentication, query parameter processing, and pagination, returning data in a predefined format. Truto provides a set of tools for your agent frameworks by offering a schema for all the Methods defined on the Resources for an integration. 

When you call the `GET /integrated-account/<id>/tools` endpoint, Truto returns all these Proxy APIs with their descriptions and JSON schemas, creating Tools that LLM frameworks can consume directly.

Here is how you fetch and bind these tools using the Truto LangChain SDK:

```typescript
import { ChatOpenAI } from "@langchain/openai";
import { TrutoToolManager } from "truto-langchainjs-toolset";

async function initializeAgent() {
  // 1. Initialize the LLM
  const model = new ChatOpenAI({ 
    modelName: "gpt-4o",
    temperature: 0 
  });

  // 2. Initialize the Truto Tool Manager with your 15Five Integrated Account ID
  const toolManager = new TrutoToolManager({
    trutoAccessToken: process.env.TRUTO_API_KEY,
    integratedAccountId: "15five-account-id-123",
  });

  // 3. Fetch all available 15Five tools for this specific tenant
  const tools = await toolManager.getTools();

  // 4. Bind the tools to the LLM natively
  const modelWithTools = model.bindTools(tools);

  return modelWithTools;
}
```

By injecting tools this way, the LLM only ever chooses from stable function names and strictly typed JSON schemas. It never invents query parameters or guesses at pagination cursors.

### Handling 15Five Rate Limits

When your agent executes complex, multi-step workflows across an organization's HR data, it will inevitably hit API rate limits. 

It is critical to understand how this is handled at the infrastructure level: **Truto does not retry, throttle, or apply backoff on rate limit errors.** When the upstream 15Five API returns an HTTP 429 Too Many Requests error, Truto passes that exact error down to your caller. 

However, Truto normalizes the upstream rate limit information into standardized headers (`ratelimit-limit`, `ratelimit-remaining`, `ratelimit-reset`) strictly following the IETF specification. Your agent framework or application layer is responsible for catching the HTTP 429 response, reading the `ratelimit-reset` header, and applying the necessary sleep or retry/backoff logic. Do not expect the infrastructure layer to magically absorb rate limit violations - build defensive delay loops into your agent's execution path.

## Hero Tools for 15Five

Below are the highest-leverage tools available for 15Five agent workflows. We skip basic CRUD operations in favor of the endpoints that enable [autonomous HR and performance automation](https://truto.one/connect-15five-to-chatgpt-run-performance-reviews-and-check-ins/).

### List All Objectives

Retrieves the core OKR data for the organization. Because the API bypasses UI privacy settings, this tool returns all objectives regardless of their visibility state in the 15Five interface.

**Usage Notes:** Use this to feed the agent context about current company goals before it attempts to generate performance reviews or validate project alignment. 

> "Fetch all active objectives for the Engineering department to verify if the upcoming infrastructure migration aligns with Q3 Key Results."

### Create a 15Five Objective

Allows the agent to programmatically generate new objectives. The payload requires a description, start and end timestamps, scope (e.g., company, department, individual), and the assigned user ID.

**Usage Notes:** The agent must construct a precise timestamp format. It can optionally include nested Key Results during the creation phase.

> "Create a new individual objective for user ID 84920 titled 'Reduce API Latency by 200ms' starting today and ending at the close of Q4."

### Update a Key Result Value

Updates the progress of an existing Key Result. This is the mechanism for keeping 15Five metrics in sync with external systems.

**Usage Notes:** Requires the unique Key Result ID and the `current_value`. The agent should check the target value first to avoid updating a metric beyond its logical ceiling.

> "Update the current value of key result ID 9921 to 45 based on the closed-won deal data I just provided."

### List All Review Cycles

Fetches active or historical performance review cycles. 

**Usage Notes:** Essential for agents tasked with generating review summaries or checking completion rates. Returns cycle IDs that are required for subsequent calls to fetch specific answers or performance measurements.

> "Retrieve the list of all review cycles to find the ID for the '2025 Mid-Year Engineering Review'."

### Create a High Five

Generates a "High Five" recognition post inside 15Five. This is a highly visible action that broadcasts praise to the organization.

**Usage Notes:** Requires the `text` (which can include @mentions) and the `creator_id`. Ensure the agent understands the social weight of this tool and does not spam the company feed.

> "Create a High Five from manager ID 112 thanking user ID 554 for their critical fix during the database outage this weekend."

### Create a User Vacation

Logs an Out of Office (OOO) period for a specific user. 

**Usage Notes:** Requires the user ID, start datetime, and end datetime. The agent must format the datetimes correctly to prevent misaligning the user's availability.

> "Log a vacation for user ID 332 starting next Monday and ending on Friday, adding a note that they are traveling with limited connectivity."

For the complete inventory of 15Five tools, schema definitions, and required parameters, visit the [15Five integration page](https://truto.one/integrations/detail/15five).

## Workflows in Action

When you bind these tools to a reasoning engine, you move beyond simple syncs and unlock autonomous HR and RevOps workflows. Here are two concrete examples of how an agent uses these tools in production.

### Scenario 1: Autonomous OKR Sync (RevOps)

**User Prompt:** 
> "Check the CRM for closed-won deals this week and update the corresponding Q3 Revenue Key Result in 15Five."

**Execution Steps:**
1. The agent searches the CRM tools (e.g., HubSpot or Salesforce) to calculate the total value of closed-won deals for the current week.
2. It calls `list_all_15_five_objectives` to scan the organization's OKRs and identify the objective related to "Q3 Revenue".
3. Upon identifying the objective, it extracts the relevant Key Result ID.
4. It calls `update_a_15_five_key_result_value_by_id`, passing the newly calculated revenue total as the `current_value`.

**Outcome:** The revenue OKR in 15Five is automatically updated without the VP of Sales manually copy-pasting numbers from the CRM, ensuring the company dashboard is always real-time.

### Scenario 2: OOO & Recognition Automation (HR Admin)

**User Prompt:** 
> "Sarah is going on PTO next week. Set her vacation in 15Five and send a High Five to David for covering her shifts."

**Execution Steps:**
1. The agent calls `list_all_15_five_users` to resolve "Sarah" and "David" into their respective 15Five user IDs.
2. It calls `create_a_15_five_user_vacation`, passing Sarah's user ID and calculating the start and end timestamps for "next week".
3. It calls `create_a_15_five_high_five`, setting the creator ID (the manager), and drafting a customized recognition message tagging David for his help.

**Outcome:** The agent handles schedule management and team morale actions in one seamless execution, formatting the timestamps and API payloads perfectly.

## Building Multi-Step Workflows

To execute the workflows above, your system needs an [orchestration loop](https://truto.one/architecting-ai-agents-langgraph-langchain-and-the-saas-integration-bottleneck/). Frameworks like LangGraph, CrewAI, or the Vercel AI SDK all follow a similar pattern: the model reasons, selects a tool, the application executes the tool, and the result is fed back into the model's context window.

Because the 15Five API enforces rate limits, your orchestration loop must explicitly handle HTTP 429 errors. Truto passes these upstream errors through and normalizes the headers, meaning your loop must check the response and apply backoff.

Here is a conceptual architecture of that loop handling rate limits safely:

```mermaid
sequenceDiagram
    participant Agent as Agent Framework
    participant Truto as Truto Proxy API
    participant Upstream as 15Five API

    Agent->>Truto: Call 15Five Tool (e.g. list_objectives)
    Truto->>Upstream: Execute Request
    Upstream-->>Truto: HTTP 429 (Rate Limited)<br>Retry-After: 5
    Truto-->>Agent: HTTP 429<br>ratelimit-reset: 1715000005
    
    Note over Agent: Agent catches 429 error<br>Calculates wait time from header<br>Sleeps thread
    
    Agent->>Truto: Retry Tool Call
    Truto->>Upstream: Execute Request
    Upstream-->>Truto: HTTP 200 OK<br>Data Payload
    Truto-->>Agent: HTTP 200 OK<br>Normalized JSON
    
    Note over Agent: Agent appends result<br>to LLM context window
```

When writing your execution logic, wrap your tool calls in a try-catch block that specifically looks for status `429`. Extract the `ratelimit-reset` header, pause execution, and retry. If you allow the LLM to handle the 429 error directly in its prompt context, it will likely hallucinate a fix or repeatedly spam the endpoint, further compounding the rate limit violation.

By handling the transport-layer logic (auth, pagination) via Truto and the network logic (retries, backoff) in your execution loop, the LLM is free to do what it does best: reason about the data.

## Redefining HR Integration Velocity

Building a custom integration for 15Five requires reading extensive API documentation, managing OAuth lifecycles, dealing with dynamic attribute schemas, and writing brittle mapping code. When you introduce an LLM into that architecture, those minor engineering annoyances turn into fatal hallucination risks.

A unified tool layer abstracts away the mechanical complexity of the 15Five API. Your agent interacts with a strict, stable JSON schema, drastically reducing the attack surface for errors while giving you immediate access to complex HR, OKR, and performance workflows.

> Stop writing defensive API wrappers for your AI agents. Let Truto handle the integration layer so you can focus on building intelligent workflows.
>
> [Talk to us](https://truto.one/book-a-demo/)