Connect Sesame to ChatGPT: Manage Personnel and Attendance

If you want to connect Sesame to ChatGPT so your AI agents can execute HR workflows, log project hours, manage employee directories, and automate absence requests, you need a Model Context Protocol (MCP) server. This server acts as the translation layer between ChatGPT's JSON-RPC tool calls and Sesame's REST API.

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

Giving a Large Language Model (LLM) read and write access to a core Human Resources Information System (HRIS) and attendance platform like Sesame is a serious engineering undertaking. You have to map flat LLM arguments into deeply nested API payloads, handle complex datetime logic for time entries, and ensure strict access control so agents don't hallucinate destructive actions. You can spend weeks building, hosting, and maintaining this middleware, or you can use a managed integration platform to dynamically generate a secure, authenticated MCP server URL in seconds.

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

The Engineering Reality of the Sesame API

Building a custom MCP server means you own the entire API lifecycle. While the MCP standard provides a predictable interface for ChatGPT to discover tools, implementing it against Sesame requires navigating several platform-specific quirks.

If you build this entirely in-house, here are the technical realities you must handle:

Silent Overwrites on Work Entries

When an LLM attempts to clock an employee in or out using the work entries endpoints, Sesame does not behave like a standard CRUD API. If you create a work entry that overlaps with an existing time block for the same employee, Sesame does not return an HTTP 409 Conflict. Instead, it silently trims, splits, or deletes the overlapping entries to accommodate the new record. Your LLM will assume a simple creation succeeded, entirely unaware that it just truncated a previous shift. Your MCP server must be designed to fetch the current day's entries immediately after a write to verify the resulting state.

Payload Inconsistencies and Nesting Quirks

Standardizing OpenAPI specs into MCP tools often breaks on undocumented edge cases. For example, when stopping a project time entry, the Sesame specification incorrectly nests the employeeId under a coordinates object. In reality, the live API requires employeeId at the top level of the payload. If you blindly pass the OpenAPI spec to an auto-generator, your LLM will construct invalid requests. Truto's proxy API handlers actively normalize these schemas so the LLM operates against reality, not just the documentation.

Handling Strict Rate Limits

Sesame enforces strict rate limiting, particularly on data-heavy endpoints like payroll and complex worked-hours reports. It is critical to understand that Truto does not retry, throttle, or apply backoff on rate limit errors. When the upstream Sesame API returns an HTTP 429 Too Many Requests, Truto passes that error directly back to the caller.

However, Truto normalizes the upstream rate limit information into standardized IETF headers (ratelimit-limit, ratelimit-remaining, ratelimit-reset). The caller (your agent framework or ChatGPT's internal execution loop) is completely responsible for reading these headers and implementing the appropriate retry and backoff logic. Do not assume the middleware will absorb 429s for you.

Creating the Sesame MCP Server

Truto derives MCP tools dynamically from your integration's configured resources and documentation records. When a customer connects their Sesame account, Truto can expose those resources as a JSON-RPC 2.0 endpoint. A tool only appears if it has corresponding documentation - this acts as a quality gate ensuring ChatGPT only sees curated, well-described endpoints.

Each MCP server is scoped to a single connected instance of Sesame. You can create this server in two ways.

Method 1: Via the Truto UI

For quick testing or one-off workflows, use the Truto dashboard to generate the server URL.

1. Log into Truto and navigate to the Integrated Accounts page for your Sesame connection.
2. Click the MCP Servers tab.
3. Click Create MCP Server.
4. Select your desired configuration (e.g., setting method filters to "read" and "write", or restricting by tags like "attendance").
5. Copy the generated MCP server URL (it will look like https://api.truto.one/mcp/a1b2c3d4...).

Method 2: Via the Truto API

For programmatic deployment - such as dynamically provisioning an AI assistant for every HR manager in your platform - use the Truto API.

The API generates a cryptographically secure token, stores its hashed value in an edge key-value store, and returns a ready-to-use URL.

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": "ChatGPT Sesame Assistant",
    "config": {
      "methods": ["read", "write"],
      "tags": ["employees", "attendance", "projects"]
    },
    "expires_at": "2026-12-31T23:59:59Z"
  }'

The response contains the exact URL you will provide to ChatGPT:

{
  "id": "mcp_12345",
  "name": "ChatGPT Sesame Assistant",
  "config": {
    "methods": ["read", "write"],
    "tags": ["employees", "attendance", "projects"]
  },
  "expires_at": "2026-12-31T23:59:59Z",
  "url": "https://api.truto.one/mcp/a1b2c3d4e5f6..."
}

Connecting the MCP Server to ChatGPT

With your server URL in hand, you need to register it as a custom connector.

Method A: Via the ChatGPT UI

If you are using ChatGPT Pro, Plus, Business, Enterprise, or Education, you can add the MCP server directly through the interface.

1. In ChatGPT, navigate to Settings -> Apps -> Advanced settings.
2. Enable Developer mode (MCP support is currently behind this flag).
3. Under MCP servers / Custom connectors, click to add a new server.
4. Enter a name (e.g., "Sesame HR System").
5. Paste the Truto MCP URL into the Server URL field.
6. Click Save.

ChatGPT will immediately perform a handshake with the /mcp/:token endpoint, requesting the tools/list operation. The server will respond with the dynamically generated Sesame tools based on your filter configuration.

Method B: Via Manual Config File

If you are testing your agent locally using an MCP-compatible framework (like LangChain, LlamaIndex, or the official MCP CLI) before deploying to production, you will use standard MCP configuration JSON. Truto provides an SSE (Server-Sent Events) transport mechanism.

Create an mcp-config.json file:

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

When your local client spins up, all arguments passed by the LLM arrive as a single flat object. Truto's router intelligently splits them into query parameters and body parameters using the schemas derived from the documentation.

Hero Tools for Sesame

Truto exposes hundreds of endpoints for Sesame, but these 6 "hero tools" offer the highest leverage for automating personnel and attendance workflows with ChatGPT.

list_all_sesame_employees

Retrieves a paginated list of Sesame employees. Truto handles the pagination via standard limit and next_cursor parameters. You can filter by status [in]=active,inactive, email, or departmentIds.

"Get a list of all active employees in the Engineering department, and grab their email addresses and current work statuses."

create_a_sesame_work_entries_clock

Automatically clocks a Sesame employee in or out based on their current state. If the employee has no open work entry, it clocks them in. If they have an open entry, it clocks them out. Setting withIncidence to true on a clock-out creates a check incidence (useful for closing entries left open overnight).

"Clock out Sarah Connor. If she left her timer running from yesterday, flag it with an incidence report so her manager knows."

create_a_sesame_time_entries_stop

Stops an employee's running project time entry. Truto normalizes the schema so the LLM correctly places the employeeId at the root of the payload, preventing upstream validation errors.

"Stop the active project timer for John Smith on the 'Website Redesign' project."

list_all_sesame_vacation_day_off_requests

Lists vacation requests, filterable by employee, validator, date range, or approval status. Ideal for compiling weekly summaries for department heads.

"Find all pending vacation requests for next month that need approval from the Marketing Director."

sesame_check_incidences_bulk_update

Updates several check incidences (clocking anomalies) at once. You can pass an array of incidence IDs and instantly set their status to accepted or rejected.

"Approve all pending clock-in incidences for the support team from yesterday, they were late due to the network outage."

create_a_sesame_contract_salary

Creates a new salary record for an employee. Sesame automatically closes the previous active salary (setting its end date to the day before the new start date). The Truto proxy captures any salary_coverage_gap warnings returned by the API.

"Update Jane Doe's contract salary to $95,000 annually starting on the 1st of next month, assigned to the standard contribution group."

For the full inventory of available tools, including resource endpoints for locations, schedules, and custom fields, visit the Sesame integration page.

Workflows in Action

Below are two real-world scenarios showing exactly how ChatGPT sequences these tools to automate HR and operational tasks.

Scenario 1: Automated Clock-In and Project Assignment

Field workers or contractors can instruct the AI to manage their time tracking without logging into the Sesame web app.

User Prompt:

"I'm starting my day. Clock me in, and then start my time on the 'Q3 Migration' project."

Agent Execution:

sequenceDiagram
    participant User
    participant ChatGPT
    participant Truto as Truto MCP Server
    participant Sesame as Sesame API

    User->>ChatGPT: "Clock me in, start 'Q3 Migration'"
    ChatGPT->>Truto: call list_all_sesame_employees (find user ID)
    Truto->>Sesame: GET /employees?email=user@domain.com
    Sesame-->>ChatGPT: employeeId: "emp_123"
    ChatGPT->>Truto: call list_all_sesame_projects (find project ID)
    Truto->>Sesame: GET /projects?name=Q3+Migration
    Sesame-->>ChatGPT: projectId: "prj_456"
    ChatGPT->>Truto: call create_a_sesame_work_entries_clock (emp_123)
    Truto->>Sesame: POST /work-entries/clock
    Sesame-->>ChatGPT: Clock-in successful
    ChatGPT->>Truto: call create_a_sesame_project_time_entry (emp_123, prj_456)
    Truto->>Sesame: POST /project-time-entries/start
    Sesame-->>ChatGPT: Project timer started
    ChatGPT-->>User: "You are clocked in and time is tracking on Q3 Migration."

What happens: ChatGPT looks up the user's employee ID, searches for the correct project ID, clocks the user into the general attendance system, and simultaneously triggers the project-specific time tracker.

Scenario 2: Resolving Time-Tracking Anomalies

Managers frequently waste time manually clearing "incidences" (e.g., an employee forgetting to clock out).

User Prompt:

"Find all the time-tracking incidences for the engineering team this week. If any of them are just people forgetting to clock out after 6 PM, approve them."

Agent Execution:

1. list_all_sesame_departments: ChatGPT queries departments to find the ID for "Engineering".
2. list_all_sesame_employees: Fetches all employees belonging to the Engineering department ID.
3. list_all_sesame_check_incidences: Filters incidences for those specific employee IDs over the past 7 days.
4. Reasoning Loop: The LLM reviews the payload data (which contains the raw checkData and timestamps), identifying which incidences match the "forgot to clock out after 6 PM" criteria.
5. sesame_check_incidences_bulk_update: The agent passes an array of the matching incidence IDs, updating their checkIncidenceStatus to accepted in a single request.

What the user gets back: "I found 14 incidences for the engineering team. 12 of them were missing clock-outs after 6 PM, which I have successfully approved. There are 2 remaining incidences regarding late arrivals that still require your manual review."

Security and Access Control

When exposing core HR systems to autonomous agents, least-privilege access is not optional. Truto's MCP architecture provides several layers of access control directly embedded in the server configuration:

• Method Filtering: Restrict the server to specific HTTP verbs. Set methods: ["read"] to give ChatGPT read-only access (allowing it to query employee directories and time-offs without the ability to create or delete records).
• Tag Filtering: Group tools by functional area. Set tags: ["attendance", "projects"] to completely hide sensitive HR tools (like salaries and contracts) from the LLM's context window.
• Time-to-Live (TTL): Use the expires_at property to create temporary MCP servers. Truto schedules a cleanup job that permanently destroys the key-value token and database record when the time expires - perfect for granting a contractor temporary AI access.
• require_api_token_auth: By default, possessing the MCP URL grants access. Setting this flag to true adds a second authentication layer, requiring the client to pass a valid Truto API token in the Authorization header to execute any tool.

Final Thoughts

Connecting ChatGPT to Sesame gives your operational and HR teams an entirely new interface for managing personnel. Instead of navigating through multiple dashboards to fix a missed clock-in or approve a vacation request, managers can instruct an AI agent to orchestrate the changes in seconds.

By leveraging Truto's auto-generated MCP servers, you bypass the massive technical debt of building and maintaining custom API integration middleware. You get strictly typed JSON schemas, standardized pagination, and normalized error handling out of the box, allowing you to focus entirely on designing the best agentic workflows for your business.