--- title: "Connect Lattice to Claude: Manage Employee Data and Feedback" slug: connect-lattice-to-claude-manage-employee-data-and-feedback date: 2026-10-25 author: Sidharth Verma categories: ["AI & Agents"] excerpt: "A complete engineering guide to connecting Lattice to Claude using a managed MCP server. Automate OKR tracking, continuous feedback, and HR tasks." tldr: "Learn how to dynamically generate a secure, managed MCP server for Lattice, allowing Claude to read and write employee data, OKRs, and performance reviews via natural language—without exposing credentials." canonical: https://truto.one/blog/connect-lattice-to-claude-manage-employee-data-and-feedback/ --- # Connect Lattice to Claude: Manage Employee Data and Feedback If your team needs to connect Lattice to Claude to automate performance review audits, track OKRs, or manage continuous feedback loops, 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 Claude's JSON-RPC 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](https://truto.one/managed-mcp-for-claude-full-saas-api-access-without-security-headaches/). If your team uses ChatGPT, check out our guide on [connecting Lattice to ChatGPT](https://truto.one/connect-lattice-to-chatgpt-track-okrs-and-performance-reviews/) 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 sprawling [HRIS and performance management ecosystem](https://truto.one/what-are-hris-integrations-the-2026-guide-for-b2b-saas-pms/) like Lattice is an engineering challenge. You have to handle API token lifecycles, map massive JSON schemas to MCP tool definitions, and deal with Lattice's domain-specific constraints. Every time Lattice updates a resource schema, you have to update your server code, redeploy, and test the integration. This guide breaks down exactly how to use Truto to generate a secure, managed MCP server for Lattice, connect it natively to Claude Desktop, and execute complex HR workflows using natural language. > Want to give your AI agents secure, authenticated access to Lattice and 100+ other SaaS APIs? Let's talk about [managed MCP architecture](https://truto.one/managed-mcp-for-claude-full-saas-api-access-without-security-headaches/). > > [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, the reality of implementing it against specialized B2B APIs is painful. Lattice is built to manage complex organizational hierarchies, cascading OKRs, and multi-stage review cycles. Its API reflects that complexity. If you decide to build a [custom Lattice MCP server](https://truto.one/the-hands-on-guide-to-building-mcp-servers-for-ai-agents-2026/), here are the specific integration challenges you will face: **The Untyped Attributes Black Hole** Many of Lattice's endpoints, particularly around task management (`list_all_lattice_tasks`), return records where the core fields are completely unenumerated. The API documentation defines the response as having an `id` and an opaque `attributes` object. Building a static tool schema for this is nearly impossible. An LLM needs explicit property definitions to know what data it can filter or update. You have to build an abstraction layer that introspects the API responses and injects structured schemas into the MCP tool definitions. **The Custom Attributes Spiderweb** Lattice leans heavily on custom attributes to adapt to different organizational structures. To fetch or update a user's custom fields, an LLM cannot simply pass `{ "department": "Engineering" }`. It has to navigate a spiderweb of endpoints: fetching the user, listing their custom attributes via `list_all_lattice_custom_attributes`, resolving the attribute definition via `get_single_lattice_custom_attribute_by_id`, and finally mapping the values. A poorly designed MCP server will leave the LLM stranded with an array of opaque UUIDs. **Strict Mutually Exclusive Payload Constraints** Lattice enforces strict domain logic on write operations. For instance, when updating a goal via `create_a_lattice_goal_update`, the payload demands exactly one of two fields: `increment` or `absolute`, alongside the `goal_id`, `comment`, and `status`. If an LLM attempts to pass both, or neither, the API throws a 400 Bad Request. Your MCP server must leverage advanced JSON Schema validation (like `oneOf` or strict descriptive prompting) to force the LLM to format the payload correctly before the request is even dispatched. ## Generating the Managed MCP Server for Lattice Truto solves these architectural challenges by dynamically generating MCP tools directly from the integration's resource definitions and schema documentation. Tools are never cached or pre-built. When Claude connects, it receives a perfectly mapped, schema-validated toolset for that specific Lattice environment. You can generate the MCP server URL for Lattice using either the Truto UI or the API. ### Method 1: Via the Truto UI This is the fastest method for internal tooling or testing. 1. Log into your Truto dashboard and navigate to your **Integrated Accounts**. 2. Select your connected Lattice account. 3. Click the **MCP Servers** tab. 4. Click **Create MCP Server**. 5. Configure the server (e.g., restrict to `methods: ["read"]` if you only want Claude to audit data). 6. Copy the generated MCP server URL (e.g., `https://api.truto.one/mcp/a1b2c3d4...`). ### Method 2: Via the API For production AI products, you should generate MCP servers programmatically on behalf of your users. This creates a secure, hashed token in Truto's infrastructure. ```typescript // POST /integrated-account/:id/mcp const response = await fetch('https://api.truto.one/integrated-account//mcp', { method: 'POST', headers: { 'Authorization': 'Bearer ', 'Content-Type': 'application/json' }, body: JSON.stringify({ name: "Lattice OKR and Feedback Assistant", config: { methods: ["read", "write"], // Allow both read and write operations tags: ["performance", "goals"] // Group tools by specific functional areas }, expires_at: "2026-12-31T23:59:59Z" }) }); const data = await response.json(); console.log(data.url); // Pass this URL to your MCP client ``` Truto validates that the Lattice integration has AI-ready tools, hashes the token via HMAC for secure storage, and returns the endpoint. ## Connecting the MCP Server to Claude Once you have the Truto MCP URL, you need to register it with your LLM client. The URL itself acts as the authentication boundary - it encodes the specific Lattice tenant and the allowed toolset. ### Method A: Via the Claude Desktop UI If you are using Claude Desktop (or ChatGPT's custom connectors), you can add the server directly through the interface: 1. Open Claude Desktop and go to **Settings**. 2. Navigate to **Integrations** or **Developer -> MCP Servers**. 3. Click **Add MCP Server**. 4. Paste your Truto MCP URL and click Add. Claude will immediately initiate the JSON-RPC `initialize` handshake, discover the tools, and they will be ready to use in your next prompt. ### Method B: Via Manual Config File For developer environments or headless agents, you can configure the MCP server manually using Claude's JSON config file, typically located at `~/Library/Application Support/Claude/claude_desktop_config.json` (Mac) or `%APPDATA%\Claude\claude_desktop_config.json` (Windows). ```json { "mcpServers": { "lattice-truto": { "command": "npx", "args": [ "-y", "@modelcontextprotocol/server-sse", "--url", "https://api.truto.one/mcp/" ] } } } ``` Restart Claude Desktop. The SSE (Server-Sent Events) transport will connect to Truto's MCP router, negotiate capabilities, and fetch the `tools/list`. ## High-Leverage Lattice Tools Truto exposes dozens of Lattice endpoints as standardized tools. By deriving these tools directly from the integration's `documentation` records, Truto guarantees that Claude understands the query and body schemas. Here are the hero tools for building agentic HR workflows. ### list_all_lattice_users Retrieves a paginated list of employees from the [Lattice directory](https://truto.one/what-are-hris-integrations-the-2026-guide-for-b2b-saas-pms/). This is the foundation for almost all workflows, as it resolves human names to Lattice user IDs. It returns the ID, email, title, status, and manager information. > "Find the Lattice user ID for John Smith in the Engineering department." ### list_all_lattice_custom_attributes Fetches all custom attributes assigned to a specific user. Because Lattice heavily customizes profiles per-company (e.g., specific compensation bands or custom office locations), this tool is critical for auditing non-standard HR data. > "List all the custom attributes for user ID 12345 and tell me their specific office location." ### get_single_lattice_review_cycle_by_id Fetches the configuration and current stage of a specific performance review cycle. It returns the cycle's name, stage, list of reviewees, and metadata, giving the LLM context on whether a cycle is active, locked, or completed. > "Check the status of the '2026 Q3 Engineering Review' cycle and list all the reviewees currently assigned to it." ### list_all_lattice_feedbacks Retrieves a stream of continuous feedback records across the organization. This allows Claude to summarize praise, constructive criticism, and peer recognition over a given time period without manually exporting CSVs. > "Pull the recent continuous feedback records for Jane Doe and summarize the key themes from her peers." ### create_a_lattice_goal Creates a new OKR or goal in Lattice. The schema requires specific fields like `name`, `startDate`, `dueDate`, and `ownerIds`. Truto's auto-generated schemas instruct Claude exactly how to format the OKR types (e.g., percentage vs monetary amounts). > "Create a new Q4 goal for me titled 'Launch Enterprise Integration API', set the due date for December 31st, and assign it to me." ### create_a_lattice_goal_update Logs a progress update against an existing goal. This tool forces the LLM to choose between passing an `increment` value or an `absolute` value, adhering to Lattice's strict mutability rules. > "Update my 'Enterprise Integration API' goal. Add an absolute progress value of 80% and add a comment saying the beta is now live." For the complete inventory of Lattice tools and their detailed JSON schemas, view the [Lattice integration page](https://truto.one/integrations/detail/lattice). ## Workflows in Action When Claude has access to these tools, it can orchestrate complex, multi-step operations that would normally require an HR admin or manager to click through a dozen web pages. ### Workflow 1: Manager Preparation for 1-on-1s A manager wants a comprehensive brief on a direct report before a 1-on-1 meeting. > "Who reports to Jane Doe? For her direct reports, find any continuous feedback they received in the last month and summarize it." **Execution Steps:** 1. Claude calls `list_all_lattice_direct_reports` passing Jane's `user_id` to get her team roster. 2. For each user ID returned, Claude calls `list_all_lattice_feedbacks` to pull their recent praise and constructive notes. 3. Claude synthesizes the JSON payloads into a concise markdown summary for the manager. ```mermaid sequenceDiagram participant Manager as Manager participant Claude as Claude Desktop participant Truto as Truto MCP Router participant Lattice as Lattice REST API Manager->>Claude: "Find Jane's direct reports and their feedback." Claude->>Truto: call list_all_lattice_direct_reports Truto->>Lattice: GET /v1/users/.../direct-reports Lattice-->>Truto: Return direct reports array Truto-->>Claude: JSON tool response Claude->>Truto: call list_all_lattice_feedbacks (per user) Truto->>Lattice: GET /v1/feedback?target_id=... Lattice-->>Truto: Return feedback records Truto-->>Claude: JSON tool response Claude-->>Manager: Summarized 1-on-1 brief ``` ### Workflow 2: Automated OKR Check-ins An employee wants to update their goals at the end of the week directly from their chat interface. > "Find my Q3 Pipeline goal and update it to reflect 75% completion. Add a comment that we closed the Acme deal today." **Execution Steps:** 1. Claude calls `list_all_lattice_me` to resolve the current user's ID. 2. Claude calls `list_all_lattice_goals_user` passing the ID to find the specific goal ID for "Q3 Pipeline". 3. Claude calls `create_a_lattice_goal_update`, passing the `goal_id`, a `status` of "on_track", the `comment` "Closed the Acme deal today", and an `absolute` progress value of 75. ## Security and Access Control When granting AI agents access to sensitive HR data, security and boundaries are paramount. Truto's MCP architecture provides several layers of control at the token level: * **Method Filtering:** You can restrict a server to `methods: ["read"]`, entirely preventing the LLM from mutating data. If Claude attempts a write operation, it won't even see the tool in the `tools/list` payload. * **Tag Filtering:** By passing `tags: ["performance"]`, you can scope the server to only expose tools related to reviews and feedback, hiding directory or compensation tools. * **Additional Authentication (`require_api_token_auth`):** By default, possessing the MCP URL grants access. By setting this flag to `true`, the standard Truto session middleware is enforced. The client must pass a valid Truto API token in the Authorization header, adding a strict secondary security layer. * **Ephemeral Access (`expires_at`):** You can assign a TTL to the MCP server. Truto uses Cloudflare KV expirations and Durable Object alarms to automatically purge the token and database records when time expires, ensuring no stale HR access remains open. ## A Note on Rate Limits Lattice imposes strict rate limits on its API. It is important to note that **Truto does not retry, throttle, or apply backoff on rate limit errors.** When the Lattice API returns an HTTP 429 Too Many Requests, Truto passes that error directly back to the caller. Truto normalizes the upstream rate limit information into standardized headers (`ratelimit-limit`, `ratelimit-remaining`, `ratelimit-reset`) per the IETF spec. The caller (or the MCP client framework) is entirely responsible for reading these headers and executing retry/backoff logic. ## Architecting for Agentic HR Connecting Lattice to Claude transforms a static HRIS into an active participant in your organization's workflows. By leveraging a documentation-driven, managed MCP server, you avoid the technical debt of building custom tool schemas, managing OAuth token lifecycles, and tracking API version deprecations. With the integration layer handled, your engineering team can focus on what actually matters: building the agentic logic, semantic routing, and user experience that makes LLM-driven HR management a reality.