Connect 15Five to ChatGPT: Run Performance Reviews and Check-ins

If you want to connect 15Five to ChatGPT so your AI agents can read performance reviews, orchestrate weekly check-ins, audit OKRs, and manage team vacations, you need a Model Context Protocol (MCP) server. This server acts as the translation layer between ChatGPT's JSON-RPC tool calls and 15Five's REST APIs. You can either spend weeks building and hosting this integration infrastructure yourself, or use a managed platform like Truto to dynamically generate a secure, authenticated MCP server URL.

If your team uses Claude, check out our guide on connecting 15Five to Claude 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 an acute engineering challenge. You have to handle dynamic attribute payloads, bypass UI-level privacy filters, and manage complex pagination models. Every time a developer adds a new objective type or changes the review cycle structure in 15Five, your custom server code must be updated, redeployed, and tested.

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

The Engineering Reality of the 15Five API

A custom MCP server is essentially a self-hosted API gateway. While the open MCP standard provides a predictable way for models to discover tools, implementing it against 15Five's specific API is exceptionally painful.

If you decide to build a custom 15Five MCP server, you own the entire API lifecycle. Here are the specific integration challenges that break standard CRUD assumptions when working with 15Five:

Privacy Settings Are Ignored by the API

In the 15Five UI, objectives and review cycles can be hidden behind strict privacy settings. However, the 15Five REST API exposes all objectives and historical data regardless of these UI privacy configurations. If you expose raw 15Five GET endpoints to ChatGPT without filtering, the LLM will have access to highly sensitive performance data that the requesting user might not normally see in the application. Your MCP layer must explicitly handle data scoping or map requests tightly to authorized IDs.

Dynamic Content Types and Custom Attributes

When querying Review Cycles or Groups in 15Five, the payload schema is not static. The attributes object returned by the API varies wildly depending on how the customer configured their review templates or group types upstream. Building static JSON Schema definitions for your MCP tools means your LLM will hallucinate field names. The MCP server must dynamically derive the expected schema from the specific 15Five tenant's configuration.

Split Authentication Domains

15Five enforces a strict divide between user-level and company-wide API keys. Operations like reading a user's own check-ins work on a standard key, but bulk user imports, accessing the company settings (GET /api/public/company/settings/), or querying all review cycles require a company admin API key. If your MCP server does not intelligently route or explicitly require the correct token scope, ChatGPT's tool calls will silently fail or return empty datasets.

Feature-Flagged Endpoints

Certain critical endpoints - like bulk exporting 1-on-1s - are hidden behind upstream feature flags in 15Five. Your integration layer cannot assume that simply because the API endpoint exists in the documentation, it is accessible to the tenant. The MCP server must handle 403 Forbidden errors gracefully and surface actionable explanations to the LLM.

Step 1: Create a 15Five MCP Server in Truto

Truto derives MCP tools dynamically from the 15Five integration's resources and documentation. You can generate a 15Five MCP server through either the Truto UI or the API.

Method 1: Via the Truto UI

1. Log into your Truto dashboard and navigate to Integrated Accounts.
2. Connect a 15Five instance (or select an existing one).
3. Click the MCP Servers tab on the integrated account page.
4. Click Create MCP Server.
5. Select your configuration. You can restrict the server to specific operations (e.g., methods: ["read"]) or specific domains (e.g., tags: ["objectives", "reviews"]).
6. Copy the generated MCP server URL (e.g., https://api.truto.one/mcp/a1b2c3d4e5f6...).

Method 2: Via the API

You can also generate MCP servers programmatically. This is useful for dynamically spinning up agent environments in your own SaaS platform.

curl -X POST https://api.truto.one/integrated-account/<15five_integrated_account_id>/mcp \
  -H "Authorization: Bearer $TRUTO_API_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{
    "name": "15Five HR Ops",
    "config": {
      "methods": ["read", "write"],
      "tags": ["objectives", "check_ins", "reviews"]
    },
    "expires_at": "2026-12-31T23:59:59Z"
  }'

The API returns a payload containing the url. This single URL handles routing, tool discovery, and authentication. Treat it as a sensitive secret.

Factual Note on Rate Limits

Truto does not retry, throttle, or apply backoff on rate limit errors. When the 15Five API returns an HTTP 429, Truto passes that error directly to the caller. Truto normalizes the upstream rate limit information into standardized headers (ratelimit-limit, ratelimit-remaining, ratelimit-reset) per the IETF specification. Your ChatGPT client or agent framework is entirely responsible for executing retry and backoff logic.

Step 2: Connect the MCP Server to ChatGPT

Once you have your Truto MCP URL, connecting it to ChatGPT takes under a minute.

Method A: Via the ChatGPT UI (Custom Connectors)

Requires ChatGPT Pro, Plus, Business, Enterprise, or Education with Developer mode enabled.

1. In ChatGPT, navigate to Settings -> Apps -> Advanced settings.
2. Toggle Developer mode on.
3. Under MCP servers / Custom connectors, click Add new server.
4. Enter a name (e.g., "15Five Performance Data").
5. Paste your Truto MCP URL into the Server URL field.
6. Click Save.

ChatGPT will immediately ping the server, run the MCP initialization handshake, and list the available 15Five tools in your chat interface.

Method B: Via Manual Config File (SSE Transport)

If you are running a local instance of an MCP inspector or using a desktop-based LLM client that requires file configuration, you can use the standard MCP SSE server command.

Create an mcp_config.json file:

{
  "mcpServers": {
    "15five_truto": {
      "command": "npx",
      "args": [
        "-y",
        "@modelcontextprotocol/server-sse",
        "--url",
        "https://api.truto.one/mcp/<your_token_here>"
      ]
    }
  }
}

15Five Hero Tools for AI Agents

Truto maps the complete 15Five API into LLM-ready tools. Here are the highest-leverage tools for automating performance and check-in workflows.

1. list_all_15_five_objectives

Retrieves a list of objectives (OKRs). Crucially, this tool fetches all objectives regardless of the UI privacy settings, providing the LLM with complete visibility into organizational goals.

"Fetch all current objectives for the engineering team and group them by their expected completion date."

2. create_a_15_five_objective

Allows the LLM to draft and publish new objectives in 15Five. This is heavily used by AI agents that assist managers in standardizing OKRs after quarterly planning meetings.

"Create a new objective for user ID 8912 titled 'Migrate core infrastructure to Kubernetes' starting today and ending on Q3 close, and add three related key results based on our planning document."

3. list_all_15_five_check_ins

Retrieves check-in reports. Because check-in structures vary by company configuration, Truto passes the dynamic attributes directly to the LLM to interpret.

"Pull the last four check-ins for the marketing team and summarize any recurring blockers they mentioned."

4. 15_five_user_vacations_bulk_update

Updates one or more vacation (out-of-office) periods. AI agents use this to parse unstructured Slack messages or emails and convert them into formal PTO updates in 15Five.

"Update Sarah's upcoming vacation record (ID 1093) - she needs to shift her start date from Monday to Tuesday."

5. list_all_15_five_review_cycle_reviews

Extracts performance reviews for a specific review cycle. Note: The API key creator must hold company admin and review admin roles for this tool to return data.

"Retrieve all performance reviews submitted for the 'H1 2026 Engineering Cycle' (ID 402) and summarize the peer feedback trends."

6. create_a_15_five_high_five

Enables the LLM to instantly generate peer recognition in the 15Five platform. The AI can format @mentions properly within the text body.

"Create a high five for @alex_dev thanking him for fixing the production database outage last night."

To see the complete tool inventory and schema definitions, visit the 15Five integration page.

Workflows in Action

Once ChatGPT has access to the 15Five MCP server, you can chain these tools together to execute complex, multi-step workflows. Here is how real teams use this setup in production.

Workflow 1: Weekly Check-in & High Five Orchestration

Managers often want to read recent check-ins and reward team members who went above and beyond, but doing so manually across a large team is tedious.

"Review the check-ins from the frontend team for this week. Identify anyone who mentioned working extra hours on the re-platforming project, and automatically send them a High Five from me thanking them for the push."

Execution Steps:

1. ChatGPT calls list_all_15_five_check_ins to fetch the recent reports.
2. The LLM parses the dynamic text fields to identify mentions of "re-platforming" and "extra hours".
3. For each identified employee, ChatGPT calls create_a_15_five_high_five passing the correct creator_id and formatting the text with the appropriate @mentions.

Result: The manager gets a brief summary in ChatGPT confirming which check-ins were analyzed and exactly who received a High Five in the 15Five platform.

Workflow 2: Performance Review & Objective Alignment Audit

HR operations teams need to ensure that the feedback given in performance reviews aligns with the employee's documented OKRs.

"Pull the reviews for the Q4 Sales Cycle (ID 882). Cross-reference the feedback given to the Account Executives against their Q4 objectives. Flag any AE whose review score was 'Exceeds Expectations' but who failed to complete their primary objectives."

Execution Steps:

1. ChatGPT calls list_all_15_five_review_cycle_reviews passing the review_cycle_id: "882".
2. ChatGPT calls list_all_15_five_objectives filtering for the specific AE user IDs to pull their Q4 goals.
3. The LLM correlates the dynamic review attributes against the objective completion status, reasoning through the text and scores.

Result: The user receives a structured audit report highlighting discrepancies between stated goals and actual review outcomes, completely bypassing manual spreadsheet exports.

sequenceDiagram
    participant User
    participant ChatGPT
    participant Truto as Truto MCP Server
    participant Upstream as 15Five API
    
    User->>ChatGPT: Run performance and OKR audit
    ChatGPT->>Truto: tools/call list_all_15_five_review_cycle_reviews
    Truto->>Upstream: GET /api/public/review/
    Upstream-->>Truto: 200 OK (Review Data)
    Truto-->>ChatGPT: JSON-RPC Result
    
    ChatGPT->>Truto: tools/call list_all_15_five_objectives
    Truto->>Upstream: GET /api/public/objective/
    Upstream-->>Truto: 200 OK (OKR Data)
    Truto-->>ChatGPT: JSON-RPC Result
    
    ChatGPT-->>User: Formatted Discrepancy Report

Workflow 3: Managing PTO and Group Reassignments

When organizational changes happen, employees change groups and their scheduled vacations need to be audited by the new manager.

"We are moving the entire 'Growth' group into the 'Core Product' group. Please list all upcoming vacations for the people being moved so the new manager is aware, and then update their group assignments."

Execution Steps:

1. ChatGPT calls list_all_15_five_groups to find the IDs for "Growth" and "Core Product".
2. ChatGPT calls get_single_15_five_group_by_id to extract the user IDs of the members in the Growth group.
3. ChatGPT calls list_all_15_five_user_vacations to check the PTO calendar for those specific users.
4. ChatGPT calls 15_five_groups_bulk_update to append the users to the new group.

Result: The LLM successfully executes a multi-resource migration in 15Five and outputs a clean list of upcoming PTO dates for the affected employees.

Security and Access Control

Giving an AI agent access to HR and performance data requires strict governance. Truto MCP servers provide multiple layers of access control at the token level:

• Method Filtering: You can restrict a server to read-only access by passing methods: ["read"] during creation. If ChatGPT attempts to call create_a_15_five_objective, the MCP server rejects it immediately.
• Tag Filtering: Limit the server's scope to specific domains. Passing tags: ["objectives"] ensures the LLM cannot even see or discover the tools related to performance reviews or vacations.
• Require API Token Auth: By setting require_api_token_auth: true, possession of the MCP URL is no longer enough. The client must also pass a valid Truto user session or API token, adding a second layer of authentication.
• Time-to-Live (TTL): Use the expires_at field to create temporary, short-lived MCP servers. Cloudflare KV handles the immediate revocation, and a Durable Object alarm permanently deletes the token record from the database.

Ship AI Workflows, Not Integration Boilerplate

Connecting ChatGPT to 15Five via standard REST requires building a custom API gateway, managing OAuth token refreshes, mapping dynamic payload schemas to JSON-RPC tools, and handling upstream rate limits.

Truto eliminates this entire class of technical debt. By dynamically generating documentation-driven MCP servers, Truto allows your engineering team to focus on agent orchestration and prompt engineering rather than maintaining 15Five API connector code. You configure the filters, grab the URL, and your LLM has immediate, secure access to 15Five.