--- title: "Connect Lattice to ChatGPT: Track OKRs and Performance Reviews" slug: connect-lattice-to-chatgpt-track-okrs-and-performance-reviews date: 2026-10-25 author: Uday Gajavalli categories: ["AI & Agents"] excerpt: "Learn how to connect Lattice to ChatGPT using Truto's managed MCP server. This guide covers UI and API setup, specific API quirks, tool schemas, and workflows." tldr: Connect Lattice to ChatGPT in minutes using Truto's MCP Server. Learn how to securely expose OKR tracking and performance reviews to your AI agents without writing custom integration boilerplate. canonical: https://truto.one/blog/connect-lattice-to-chatgpt-track-okrs-and-performance-reviews/ --- # 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](https://truto.one/what-is-mcp-and-mcp-servers-and-how-do-they-work/). This server acts as the translation layer between [ChatGPT's tool calls](https://truto.one/what-is-llm-function-calling-for-integrations-2026-guide/) and Lattice's REST APIs. You can either [build and maintain this infrastructure yourself](https://truto.one/the-hands-on-guide-to-building-mcp-servers-for-ai-agents-2026/), 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](https://truto.one/connect-lattice-to-claude-manage-employee-data-and-feedback/) or explore our broader architectural overview on [connecting Lattice to AI Agents](https://truto.one/connect-lattice-to-ai-agents-automate-org-hierarchies-and-updates/). 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. > Stop writing boilerplate API integration code. Let Truto generate secure, managed MCP servers for your AI agents in seconds. > > [Talk to us](https://truto.one/book-a-demo/) ## 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](https://truto.one/auto-generated-mcp-tools-for-ai-agents-a-2026-architecture-guide/) 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/`. **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`. ```bash 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`. ```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](https://truto.one/integrations/detail/lattice). ## 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. ```mermaid 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. > Ready to give your AI agents secure access to Lattice? Let Truto generate your managed MCP server today. > > [Talk to us](https://truto.one/book-a-demo/)