Connect Lattice to ChatGPT: Track OKRs and Performance Reviews

If you need to connect Lattice to ChatGPT so your AI agents can read performance reviews, track OKRs, synthesize feedback, and update goal progress, you need a Model Context Protocol (MCP) server. This server acts as the translation layer between ChatGPT's tool calls and Lattice's REST APIs. You can either build and maintain this infrastructure yourself, or use a managed integration platform like Truto to dynamically generate a secure, authenticated MCP server URL.

If your team uses Claude, check out our guide on connecting Lattice to Claude or explore our broader architectural overview on connecting Lattice to AI Agents.

Giving a Large Language Model (LLM) read and write access to a human resources and performance management platform like Lattice is a significant engineering challenge. You must handle complex relational data payloads, navigate deeply nested goal structures, and ensure strict access control. Every time an agent attempts to update an OKR, your custom server code must translate flat LLM arguments into Lattice's specific request body schemas.

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

The Engineering Reality of the Lattice 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, implementing it against Lattice's specific API quirks is exceptionally painful.

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

Polymorphic Goal Updates

When an LLM attempts to update an OKR in Lattice, it cannot simply pass a flat completion percentage. The Lattice API expects goal updates to follow strict schemas depending on how the goal is measured. You must explicitly define whether the update is an increment (adding to the existing progress) or an absolute value (setting a new total). If your MCP server does not accurately map the LLM's intent to these mutually exclusive fields, the API will reject the request.

Opaque and Untyped Data Models

Certain Lattice endpoints obscure their data models. For example, the task endpoint (list_all_lattice_tasks) returns an unenumerated attributes object rather than a strictly typed schema. LLMs operate entirely on schema definitions. If you do not explicitly map and document these opaque attributes in your custom MCP server, ChatGPT will have no idea what fields exist, leading to severe hallucinations. Truto handles this by using documentation-driven tool generation to inject explicit JSON schemas for the model to follow.

Strict Rate Limits and Concurrency

AI agents are inherently concurrent. A single prompt like "Get me the reviews for all my direct reports" might cause ChatGPT to fire five parallel tool calls to the Lattice API. Lattice enforces strict rate limits, and when those limits are breached, it returns an HTTP 429 status code.

It is critical to note that Truto does not automatically retry, throttle, or apply backoff when these rate limit errors occur. Instead, Truto passes the 429 error directly back to the caller (ChatGPT), while normalizing the upstream rate limit information into standardized IETF headers (ratelimit-limit, ratelimit-remaining, ratelimit-reset). The caller - whether that is ChatGPT, LangChain, or your custom orchestration layer - is entirely responsible for reading these headers and executing the appropriate retry and backoff logic.

Lattice to ChatGPT Quickstart Guide

If you just want the fastest path from a fresh Truto account to ChatGPT calling the Lattice API, follow these steps. Deeper architecture and security details live in the sections below.

What you need:

• A Truto account with API access.
• A Lattice admin who can provide an API token.
• A ChatGPT Pro, Plus, Business, Enterprise, or Education seat with Developer mode available.

Step 1: Connect Lattice to Truto

In the Truto dashboard, open Integrated Accounts -> New Integrated Account, select Lattice, and input your Lattice API token. Truto securely stores this credential and handles the authentication headers for all downstream requests.

Step 2: Generate the Lattice MCP Server

You can generate the MCP server using either the Truto UI or the API.

Method 1: Via the Truto UI

1. Navigate to the Integrated Account page for your Lattice connection.
2. Click the MCP Servers tab.
3. Click Create MCP Server.
4. Select your desired configuration (e.g., restrict to read methods only).
5. Copy the generated MCP server URL. It will look like https://api.truto.one/mcp/<token>.

Method 2: Via the API You can programmatically scope an MCP endpoint to your Lattice account using the Truto API. You will need your integrated_account_id.

curl -X POST https://api.truto.one/integrated-account/$INTEGRATED_ACCOUNT_ID/mcp \
  -H "Authorization: Bearer $TRUTO_API_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{
    "name": "Lattice MCP for ChatGPT",
    "config": {
      "methods": ["read", "write"],
      "tags": ["goals", "reviews", "users"]
    }
  }'

The response contains a url field. That single URL carries routing and authentication - treat it like a secret.

Step 3: Connect the MCP Server to ChatGPT

You can register this server directly in the ChatGPT UI, or via a local configuration file if you are using a desktop orchestration tool.

Method A: Via the ChatGPT UI

1. In ChatGPT, click your profile picture and navigate to Settings -> Apps -> Advanced settings.
2. Enable Developer mode.
3. Under MCP servers / Custom connectors, click to add a new server.
4. Name: "Lattice (Truto)"
5. Server URL: Paste the Truto MCP URL you copied in Step 2.
6. Click Save. ChatGPT will immediately connect and list the available Lattice tools.

Method B: Via Manual Config File If you are running a custom desktop agent or testing via the MCP inspector, you can add the Truto URL using the standard Server-Sent Events (SSE) transport in your mcp_config.json.

{
  "mcpServers": {
    "lattice-truto": {
      "command": "npx",
      "args": [
        "-y",
        "@modelcontextprotocol/server-sse",
        "--url",
        "https://api.truto.one/mcp/a1b2c3d4e5f6..."
      ]
    }
  }
}

Hero Tools for Lattice

Truto automatically generates MCP tools based on the available Lattice API endpoints and their documentation. When ChatGPT connects, it receives exact JSON Schema definitions for every required query and body parameter.

Here are the most high-leverage tools available for Lattice performance management workflows.

1. List All Lattice Users

list_all_lattice_users

Retrieves a paginated list of users in the Lattice directory. This tool is essential for AI agents to resolve natural language names (e.g., "John Smith") into the exact Lattice user IDs required by downstream operations. It returns the user's id, email, name, title, status, and manager ID.

"Find the Lattice user ID for Sarah Connor, and tell me who her manager is."

2. List All Lattice Goals

list_all_lattice_goals

Fetches a paginated list of goals (OKRs) across the organization. The agent can use this to review the state, okrType, currentAmount, dueDate, and owners of various goals.

"Pull the current list of goals for the engineering department and summarize which ones are falling behind their target metrics."

3. Create a Lattice Goal Update

create_a_lattice_goal_update

Allows the AI agent to log progress on a specific OKR. This requires the goal_id, a comment, the status, and either an increment or absolute numerical value. Because Truto enforces the JSON Schema, ChatGPT knows exactly how to structure this complex payload without hallucinating fields.

"Update the progress on my Q3 Marketing pipeline goal. Add an increment of 15, mark the status as 'on track', and add the comment: 'Webinar campaign yielded strong early results.'"

4. List All Lattice Feedbacks

list_all_lattice_feedbacks

Retrieves continuous feedback records. This is highly useful for managers wanting a quick synthesis of recent praise or constructive feedback given to their direct reports. It returns the author, the body of the feedback, visibility settings, and timestamps.

"Get all the continuous feedback given to Alex this quarter and summarize the key strengths highlighted by his peers."

5. List All Lattice Review Cycles

list_all_lattice_review_cycles

Fetches all performance review cycles in Lattice. The agent uses this to find the specific id of an active or past review cycle before drilling down into individual reviewees.

"List all the review cycles from 2025 and find the ID for the 'H1 2025 Engineering Performance Review'."

6. List All Lattice Reviews

list_all_lattice_reviews

Retrieves all reviews for a specific reviewee. This tool gives the LLM access to the raw review data, including the reviewer, the specific question asked, the reviewType, and the submitted responses.

"Fetch all the reviews submitted for David in the recent cycle. Synthesize the feedback into three key areas of improvement and two major achievements."

For the complete tool inventory, including endpoints for custom attributes, departments, tasks, and continuous updates, view the Lattice integration page.

Workflows in Action

Once the MCP server is connected, ChatGPT can chain multiple tools together to accomplish complex, multi-step tasks that normally require significant clicking around the Lattice UI.

Scenario 1: Friday OKR Check-in Automation

Instead of logging into Lattice, finding a specific goal, and calculating the new progress number, a user can simply instruct ChatGPT to handle their Friday updates.

"I just closed 5 new enterprise deals this week. Find my Q3 Enterprise Sales goal and update the progress. Add a comment that says 'Strong close to the week, pipeline is looking healthy.'"

How the agent executes this:

1. Calls list_all_lattice_me to resolve the current user's ID.
2. Calls list_all_lattice_goals_user passing the user_id to find the exact ID of the "Q3 Enterprise Sales" goal.
3. Calls create_a_lattice_goal_update passing the goal_id, increment: 5, status: "on track", and the user's comment.

The user receives a confirmation from ChatGPT that the progress has been officially logged in Lattice.

Scenario 2: Manager Performance Review Synthesis

During review season, managers spend hours reading disparate feedback and trying to synthesize it into a cohesive narrative. ChatGPT can orchestrate this entire data-gathering process.

"I need to write the performance review for Sarah. Find the most recent review cycle, get all her reviews from her peers, and fetch any continuous feedback she received this year. Synthesize all of this into a bulleted list of themes."

How the agent executes this:

1. Calls list_all_lattice_users to find Sarah's user ID.
2. Calls list_all_lattice_review_cycles to identify the ID of the current active cycle.
3. Calls list_all_lattice_reviewees to confirm Sarah's participation and ID within that specific cycle.
4. Calls list_all_lattice_reviews passing the reviewee_id to extract the peer and manager review text.
5. Calls list_all_lattice_feedbacks to pull continuous feedback from the broader year.
6. ChatGPT processes the returned JSON data in its context window and outputs a clean, synthesized markdown summary of Sarah's performance themes.

sequenceDiagram
    participant User as User
    participant Agent as ChatGPT
    participant Truto as Truto MCP Server
    participant Lattice as Lattice API

    User->>Agent: "Synthesize Sarah's reviews"
    Agent->>Truto: Call list_all_lattice_users
    Truto->>Lattice: GET /v1/users
    Lattice-->>Truto: User data
    Truto-->>Agent: Returns Sarah's ID
    
    Agent->>Truto: Call list_all_lattice_reviews
    Truto->>Lattice: GET /v1/reviews?reviewee_id=123
    Lattice-->>Truto: Review payloads
    Truto-->>Agent: JSON review data
    
    Agent-->>User: Delivers synthesized markdown summary

Security and Access Control

Exposing an HRIS and performance management platform to an AI agent requires strict guardrails. Truto provides several configuration levers at the MCP token level to ensure ChatGPT only accesses what it should.

• Method Filtering: You can restrict the server to specific HTTP methods by configuring methods: ["read"]. This ensures ChatGPT can only execute get and list operations, physically preventing the AI from creating or updating goals and reviews.
• Tag Filtering: You can constrain the toolset by functional area. Setting tags: ["goals"] ensures the MCP server only exposes OKR-related tools, hiding sensitive review or continuous feedback endpoints from the model.
• Token Expiration: You can configure expires_at with an ISO datetime. This is highly useful for granting temporary agent access (e.g., generating a server URL that automatically self-destructs at the end of the performance review cycle).
• Extra Authentication: By default, possessing the MCP URL grants access. For higher security, enabling require_api_token_auth: true forces the client to also pass a valid Truto API token in the Authorization header, adding a secondary identity check.

Stop Writing Integration Boilerplate

Connecting Lattice to ChatGPT does not require you to write a custom schema parser, handle OAuth flows, or maintain a self-hosted integration layer. By leveraging Truto's dynamic, documentation-driven MCP generation, you can give your AI agents secure, schema-perfect access to Lattice in minutes.

Focus your engineering cycles on building better AI agent prompts and orchestration logic - let Truto handle the underlying API infrastructure.