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. 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.

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

Giving a Large Language Model (LLM) read and write access to a sprawling HRIS and performance management ecosystem 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.

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, 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.

// POST /integrated-account/:id/mcp
const response = await fetch('https://api.truto.one/integrated-account/<lattice_account_id>/mcp', {
  method: 'POST',
  headers: {
    'Authorization': 'Bearer <TRUTO_API_TOKEN>',
    '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).

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

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. 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.

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.

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.