Connect 15Five to Claude: Sync OKRs, Key Results, and Priorities

If you need to connect 15Five to Claude to automate OKR tracking, update key results, extract check-in insights, or manage team priorities, you need a Model Context Protocol (MCP) server. This server acts as the translation layer between Claude's function calls and 15Five's REST API. You can either build and maintain this integration infrastructure yourself, or use a managed platform like Truto to dynamically generate a secure, authenticated MCP server URL. If your team uses ChatGPT, check out our guide on connecting 15Five to ChatGPT or explore our broader architectural overview on connecting 15Five to AI Agents.

Giving a Large Language Model (LLM) read and write access to a performance management platform like 15Five is a significant engineering challenge. You must handle complex token lifecycles, map unstructured dynamic attributes to predictable JSON schemas for the model, and contend with strict rate limits. Every time 15Five alters an endpoint or deprecates a resource, you must update your custom server code, redeploy, and validate the new integration.

This guide breaks down exactly how to use Truto to generate a secure, managed MCP server for 15Five, connect it natively to Claude, and execute complex performance management workflows using natural language.

The Engineering Reality of the 15Five API

A custom MCP server is a self-hosted integration layer. While the open MCP standard provides a predictable way for models to discover tools, the reality of implementing it against 15Five's API requires dealing with domain-specific quirks that will easily break a naive integration.

If you decide to build a custom MCP server for 15Five, here are the specific integration challenges you will face:

Data Privacy Overrides at the API Level In the 15Five UI, certain objectives or key results can be hidden based on privacy settings and user hierarchy. However, when querying the objectives endpoint via the API, all objectives are fully available regardless of UI privacy configurations. If you expose this endpoint directly to an LLM without an intermediary scoping mechanism or strict user context, the LLM will hallucinate or leak highly sensitive compensation or performance goals that the interacting user should not see. Building an MCP server means you have to implement application-level RBAC on top of the API response before handing it to Claude.

Dynamic Attribute Schemas 15Five uses highly configurable structures for groups, check-ins, and one-on-ones. When querying get_single_15_five_group_by_id or get_single_15_five_check_in_by_id, the API returns a base entity with an attributes object. The fields inside this attributes object vary entirely based on how the tenant configured their group types or check-in templates upstream. LLMs struggle with undefined schema shapes. To get Claude to reliably update or parse a check-in, your MCP server must first fetch the tenant's configuration, dynamically generate a JSON Schema for the tool, and inject it into the MCP tools/list response at runtime.

Strict Rate Limits and Error Passthrough 15Five enforces strict API rate limits to prevent abuse, typically returning HTTP 429 errors when thresholds are breached. A critical architectural detail to understand is that Truto does not automatically retry, throttle, or apply backoff on rate limit errors. When the 15Five API returns a 429, Truto passes that error directly to the caller (the LLM). However, Truto normalizes the upstream rate limit information into standardized headers (ratelimit-limit, ratelimit-remaining, ratelimit-reset) per the IETF specification. This means the LLM or your agentic framework is responsible for reading these headers and orchestrating its own backoff logic.

How to Create the 15Five MCP Server

Truto's MCP servers feature turns any connected 15Five account into an MCP-compatible JSON-RPC 2.0 endpoint. Rather than hand-coding tool definitions, Truto derives them dynamically from the integration's resource configurations and documentation.

You can generate an MCP server URL through the Truto UI or programmatically via the API.

Method 1: Via the Truto UI

If you are configuring this manually for an internal team:

1. Log into your Truto dashboard and navigate to the integrated account page for the 15Five connection.
2. Click the MCP Servers tab.
3. Click Create MCP Server.
4. Select the desired configuration. You can filter by methods (e.g., read-only) or specific resource tags to limit the LLM's access.
5. Copy the generated MCP server URL. This URL contains a cryptographic token that securely authenticates the connection.

Method 2: Via the Truto API

For developers building programmatic infrastructure, you can generate the MCP server dynamically via a POST request to the Truto API. This is ideal for generating ephemeral servers scoped to a specific user session.

Endpoint: POST /integrated-account/:id/mcp

const response = await fetch('https://api.truto.one/integrated-account/<15five_account_id>/mcp', {
  method: 'POST',
  headers: {
    'Authorization': 'Bearer <YOUR_TRUTO_API_TOKEN>',
    'Content-Type': 'application/json'
  },
  body: JSON.stringify({
    name: "Claude 15Five Integration",
    config: {
      methods: ["read", "write"] // Restrict to specific operations if needed
    },
    expires_at: "2026-12-31T23:59:59Z" // Optional TTL for ephemeral access
  })
});
 
const data = await response.json();
console.log(data.url); // The MCP server URL to pass to Claude

The Truto API validates that the 15Five integration actually has documented tools available. If successful, it hashes the secure token, stores the metadata, and returns a ready-to-use url.

Connecting the MCP Server to Claude

Once you have the Truto MCP server URL, you need to register it with your Claude environment. This can be done via the client UI or via a configuration file depending on your setup.

Method A: Via the Claude UI

If you are using Claude Desktop or the Claude Web Interface with custom connector support:

1. Open Claude and navigate to Settings.
2. Locate the Integrations or Connectors section.
3. Click Add MCP Server or Add custom connector.
4. Paste the Truto MCP URL you generated in the previous step.
5. Click Add. Claude will immediately initiate a handshake, parse the tools/list JSON-RPC response, and register the 15Five tools.

Method B: Via Manual Configuration File

If you are running Claude Desktop locally for development, you can register the server by editing the claude_desktop_config.json file. Truto's MCP servers communicate over HTTP using Server-Sent Events (SSE).

Add the following configuration to your file:

{
  "mcpServers": {
    "15five-truto": {
      "command": "npx",
      "args": [
        "-y",
        "@modelcontextprotocol/server-sse",
        "<YOUR_TRUTO_MCP_URL>"
      ]
    }
  }
}

Restart Claude Desktop. The application will execute the command, establishing an SSE connection to the Truto MCP endpoint and importing the 15Five tools.

15Five Hero Tools for Claude

Truto dynamically generates specific, strongly-typed tools based on the 15Five API schema. Instead of dealing with generic REST paths, Claude sees explicit, descriptive functions. Here are the most powerful tools available for performance management workflows:

list_all_15_five_objectives

This tool retrieves a list of objectives (OKRs) configured in 15Five. It returns standard identifiers and timestamps. Note that objectives are fully visible via the API regardless of UI privacy settings, so you must rely on downstream filtering or trust the LLM prompt context.

"Fetch all objectives for the engineering department for this quarter. Filter the list to only show objectives that are currently active and provide a summary of the remaining work."

create_a_15_five_key_result

This tool creates one or more key results and attaches them to existing 15Five objectives. The request body requires an array of items, each needing an objective_id and a description.

"Create a new key result under the Q3 Infrastructure objective (ID: 98234) with the description 'Migrate 50% of legacy VMs to the new cloud provider by November'."

15_five_priorities_bulk_update

Allows the LLM to update one or more priorities simultaneously. This is highly useful for automating end-of-week wrap-ups where multiple priority statuses change at once. Requires an array of items identified by id and the updated text or status.

"Update my top two priorities for this week. Mark priority ID 10293 as completed, and change the text of priority ID 10294 to 'Finalize the database schema review'."

get_single_15_five_check_in_by_id

Retrieves a specific check-in report. The response includes the id and a dynamic attributes object whose fields depend entirely on the tenant's specific check-in configuration and custom questions.

"Retrieve the details for check-in ID 8472. Summarize the user's blockers and list the custom questions they were asked this week."

create_a_15_five_high_five

Generates a recognition record (High Five) in the system. The payload requires the text of the recognition (including @mentions) and the creator_id. This is excellent for automating positive feedback based on completed tasks in a project management system.

"Create a high five from me (ID: 555) to Sarah (ID: 444). The message should be: 'Huge thanks to @sarah for staying late and shipping the new billing service ahead of schedule!'"

15_five_user_vacations_bulk_update

Updates one or more vacation (out-of-office) records in 15Five. This is crucial for syncing time-off data from an external HRIS system into the 15Five calendar. Requires id, start_dt, and end_dt per item.

"Update the vacation record ID 7732 to reflect a new end date of Friday this week, as the employee has extended their time off."

For the complete tool inventory, required arguments, and JSON schemas, view the 15Five integration page.

Workflows in Action

When connected to a capable LLM like Claude 3.5 Sonnet, these tools can be chained together to execute complex, multi-step performance management operations. Here is how Claude handles real-world scenarios.

sequenceDiagram
    participant User as User
    participant Claude as Claude Desktop
    participant Truto as Truto MCP Server
    participant Upstream as "Upstream API (15Five)"

    User->>Claude: "Update my OKRs and check-ins..."
    Claude->>Truto: JSON-RPC tools/call (list_all_15_five_objectives)
    Truto->>Upstream: GET /api/public/objective/
    Upstream-->>Truto: JSON Array (Objectives)
    Truto-->>Claude: Result Object
    Claude->>Truto: JSON-RPC tools/call (create_a_15_five_key_result)
    Truto->>Upstream: POST /api/public/key-result/
    Upstream-->>Truto: 201 Created
    Truto-->>Claude: Result Object
    Claude-->>User: "I have updated your OKRs."

Scenario 1: Quarterly OKR Review and Update

An engineering manager wants to transition team objectives for the new quarter based on a planning document.

"Analyze our current Q3 engineering objectives. Create a new key result under the 'Infrastructure Hardening' objective for 'Migrate 50% of legacy VMs'. Then, update my priorities for this week to reflect this new focus."

1. list_all_15_five_objectives: Claude queries the active objectives to find the ID for "Infrastructure Hardening".
2. create_a_15_five_key_result: Using the ID found in step 1, Claude creates the new key result for migrating legacy VMs.
3. list_all_15_five_priorities: Claude checks the manager's current priorities for the week.
4. 15_five_priorities_bulk_update: Claude appends a new priority relating to the VM migration to the manager's active list.

The manager receives a natural language confirmation that the OKRs are aligned and their weekly tracking reflects the new quarter's focus.

Scenario 2: Weekly Check-In & Team Recognition

A department lead wants to quickly review weekly status reports and reward team members who hit major milestones.

"Pull my team's check-ins from this week. Find who successfully completed their top priorities, and create a high five for Sarah tagging her for shipping the new billing service."

1. list_all_15_five_groups: Claude retrieves the ID for the department lead's specific group/team.
2. list_all_15_five_check_ins: Claude fetches the recent check-in reports for the team members identified in the group.
3. create_a_15_five_high_five: After parsing the check-ins to verify Sarah's success, Claude constructs a payload to post a public high five, tagging her and referencing the billing service.

The lead saves 30 minutes of clicking through menus, handling team morale and status review entirely via chat.

Security and Access Control

Giving AI models access to performance and HR data requires strict guardrails. Truto's managed MCP architecture provides several layers of security to limit the blast radius of an autonomous agent:

• Method Filtering: When generating an MCP server, you can pass config: { methods: ["read"] }. This drops all create, update, and delete tools from the MCP server entirely. If the LLM hallucinates a command to modify an OKR, the tool simply does not exist.
• Tag Filtering: You can scope a server to specific functional areas. By passing tags: ["okrs"], the server will only expose objective and key result tools, completely hiding check-in or vacation data from the LLM.
• Dual Authentication (require_api_token_auth): By default, the cryptographically signed MCP URL is sufficient to connect. For environments where the URL might end up in a shared config file, you can set require_api_token_auth: true. The connecting client must then also provide a valid Truto API token in the Authorization header to access the tools.
• Ephemeral Tokens (expires_at): You can assign an ISO datetime to the expires_at field. Once the timestamp passes, the token is automatically wiped from Truto's KV storage, severing the LLM's access instantly without manual intervention.
• Token Hashing: Truto hashes the MCP token before persisting it to the backing store. The raw token is only returned once during the initial generation, ensuring that compromised internal infrastructure cannot be used to reverse-engineer access.

Connect Your AI Agents to 15Five

Building a custom integration between an LLM and 15Five requires navigating unstructured dynamic schemas, mapping out undocumented privacy overrides, and handling manual rate limit backoffs. A custom MCP server means owning that technical debt forever.

Truto's managed MCP architecture removes the maintenance burden entirely. By mapping 15Five's documented resources to JSON-RPC endpoints dynamically, your AI agents get immediate, secure, and fully-typed access to performance management workflows.