Connect Polymer to Claude: Track Applications and Hiring Stages

If you need to connect Polymer to Claude to automate applicant tracking, manage hiring pipelines, or generate interview reviews, you need a Model Context Protocol (MCP) server. This server acts as the translation layer between Claude's natural language tool calls and Polymer's REST APIs. You can either spend weeks building and maintaining 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 Polymer to ChatGPT or explore our broader architectural overview on connecting Polymer to AI Agents.

Giving a Large Language Model (LLM) read and write access to your recruiting operations is a significant engineering challenge. You must handle OAuth 2.0 token lifecycles, map massive JSON schemas to MCP tool definitions, and deal with strict pagination and stage-gate constraints. Every time an endpoint updates or a schema drifts, 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 Polymer, connect it natively to Claude, and execute complex hiring workflows using natural language.

The Engineering Reality of the Polymer 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 a specialized Applicant Tracking System (ATS) like Polymer is painful. You are not just integrating a simple key-value store - you are integrating a relational pipeline of jobs, candidates, applications, and strict hiring stages.

If you decide to build a custom MCP server for Polymer, you own the entire API lifecycle. Here are the specific challenges you will face:

The Candidate vs Application Disconnect In Polymer, a Candidate and an Application are strictly separated entities. A candidate is a person. An application is that person's relationship to a specific job. LLMs frequently hallucinate operations, trying to "move a candidate to the next stage" or "reject a candidate." Polymer APIs will reject this. You must move the Application. Your MCP server must provide explicit, highly-documented JSON schemas to prevent the model from conflating these two resources.

Strict Stage Transitions and UUIDs Polymer does not let you update an application's stage by passing a string like "Phone Screen" or "Final Interview". Hiring stages are uniquely generated UUIDs tied to the specific job requisition. To move an application, an LLM cannot guess the stage ID. It must first call a tool to list the job's hiring stages, parse the response to find the correct UUID for "Phone Screen", and then pass that exact UUID into the stage move payload. If your MCP tools do not enforce this sequence, your agent will fail constantly.

Rate Limits and 429 Handling When an AI agent starts summarizing dozens of candidate applications or querying historical interview reviews, it will rapidly hit Polymer's API rate limits. It is critical to understand that Truto does not retry, throttle, or apply backoff on rate limit errors. When Polymer returns an HTTP 429 Too Many Requests, Truto passes that error directly to the caller. Truto normalizes the upstream rate limit information into standardized headers (ratelimit-limit, ratelimit-remaining, ratelimit-reset) per the IETF specification. The caller - your MCP client or agent framework - is entirely responsible for implementing its own retry and exponential backoff logic.

How to Generate a Polymer MCP Server with Truto

Truto dynamically generates MCP tools based on the resources and documentation defined in your Polymer integration. Instead of hand-coding tool definitions, Truto translates Polymer's API documentation into JSON Schema formats that Claude can natively understand.

Each MCP server is scoped to a single integrated account (a specific tenant's connected Polymer instance). The server URL contains a cryptographic token that encodes the account routing, filter configurations, and expiration.

You can create this server through the Truto UI or programmatically via the API.

Method 1: Via the Truto UI

If you are setting up an internal automation for your own recruiting team, the dashboard is the fastest route.

1. Navigate to the Integrated Accounts page in your Truto dashboard.
2. Select the connected Polymer account you want to use.
3. Click the MCP Servers tab.
4. Click Create MCP Server.
5. Configure the server (assign a name, optionally filter to specific operations like read or write, and set an expiration date).
6. Copy the generated MCP server URL (e.g., https://api.truto.one/mcp/abc123def456...).

Method 2: Via the Truto API

If you are building an AI product and need to generate MCP servers for your customers dynamically, you use the /mcp REST endpoint. The API validates the configuration, generates a secure edge-stored token, and returns a ready-to-use URL.

curl -X POST "https://api.truto.one/integrated-account/{integrated_account_id}/mcp" \
  -H "Authorization: Bearer YOUR_TRUTO_API_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{
    "name": "Polymer Pipeline Agent",
    "config": {
      "methods": ["read", "write", "custom"],
      "tags": ["recruiting", "applications"]
    },
    "expires_at": "2026-12-31T23:59:59Z"
  }'

The response contains the exact URL you will provide to the Claude client:

{
  "id": "mcp_srv_98765",
  "name": "Polymer Pipeline Agent",
  "config": {
    "methods": ["read", "write", "custom"],
    "tags": ["recruiting", "applications"]
  },
  "expires_at": "2026-12-31T23:59:59Z",
  "url": "https://api.truto.one/mcp/xyz987..."
}

Connecting the MCP Server to Claude

Once you have your Truto MCP URL, you can connect it directly to Claude Desktop or any compatible MCP client. The server URL contains everything needed to authenticate and route the tool calls.

Method A: Via the Claude UI (Desktop)

Anthropic natively supports remote MCP servers in Claude Desktop.

1. Open Claude Desktop.
2. Navigate to Settings -> Integrations -> Add MCP Server.
3. Enter a name for the server (e.g., "Polymer ATS").
4. Select the connection type (Server-Sent Events / SSE).
5. Paste your Truto MCP URL.
6. Click Add.

Claude will immediately execute an initialize handshake, request tools/list, and populate the UI with the available Polymer operations.

Method B: Via Manual Config File

If you are configuring Claude Desktop manually or running a headless agent framework, you can inject the server via the claude_desktop_config.json file. Because Truto provides an HTTP SSE endpoint, you use the standard @modelcontextprotocol/server-sse wrapper.

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

Restart Claude after updating the configuration file.

Hero Tools for Polymer Automations

Truto exposes Polymer's API footprint as distinct, schema-validated tools. Below are the highest-leverage tools for pipeline and candidate automation. Do not use these tools blindly - they have strict relational dependencies.

List All Polymer Candidates

Returns a paginated collection of candidate records across the entire organization. This is your primary discovery tool for finding individuals by email or name before interacting with their specific applications.

Tool Name: list_all_polymer_candidates

"Find the candidate record for jane.doe@example.com in Polymer and summarize her overall profile data."

List All Polymer Job Applications

Retrieves the application records that link candidates to specific job postings. You must use this tool to discover the job_application_id, which is required for almost all downstream mutation tasks (moving stages, adding reviews).

Tool Name: list_all_polymer_job_applications

"List the active job applications for the candidate ID 847291 and tell me which jobs they are currently interviewing for."

List All Polymer Job Hiring Stages

This is a critical metadata operation. Before you can move an application forward or backward in the pipeline, you must retrieve the valid hiring stages for the specific job. Stages vary by requisition.

Tool Name: list_all_polymer_job_hiring_stages

"Get the hiring stages for job ID 50921 so we can find the exact stage ID for the 'Onsite Interview' step."

Create a Polymer Job Application Stage Move

Moves a candidate's application from its current stage to a new stage. This requires both the job_application_id and the destination stage ID.

Tool Name: create_a_polymer_job_application_stage_move

"Move the job application ID 10934 to the 'Offer Extended' stage using the stage ID you found previously."

Create a Polymer Job Application Review

Submits structured interviewer feedback or scorecard data attached to a specific job application. This is ideal for agents that summarize call transcripts and automatically post the resulting feedback into the ATS.

Tool Name: create_a_polymer_job_application_review

"Create a new review for application ID 10934 stating that the technical screen was highly successful, specifically noting their strong system architecture knowledge."

Create a Polymer Job Resume Export

Triggers an export job to retrieve the raw resume document associated with a specific job profile or candidate. Essential for agents that need to perform deep skill matching against job descriptions.

Tool Name: create_a_polymer_job_resume_export

"Generate a resume export for job ID 50921 so I can review the attached document against our required qualifications."

List All Polymer Job Application Comments

Retrieves the conversational thread and recruiter notes attached to an application. This provides critical historical context before an agent drafts an email to a candidate or summarizes pipeline status.

Tool Name: list_all_polymer_job_application_comments

"Pull all the comments on application ID 10934 and summarize the hiring manager's concerns from last week."

For the complete inventory of available Polymer operations, including schemas and custom methods, visit the Polymer integration page.

Workflows in Action

Connecting tools to Claude is only the first step. The real value comes from orchestrating multi-step workflows that understand Polymer's relational data model. Here are two concrete examples of how Claude executes these operations.

Workflow 1: Pipeline Triage and Automated Review Drafting

A hiring manager wants to process a candidate who just finished a technical interview, using notes pasted into the chat interface.

"I just interviewed Jane Smith for the Senior Backend Engineer role. She did great on the system design portion but struggled slightly with the database indexing questions. Overall, it's a hire. Please find her active application, add this feedback as a formal review, and tell me what the next stages are."

Execution Steps:

1. Claude calls list_all_polymer_candidates filtering by the name "Jane Smith" to retrieve her internal candidate ID.
2. Claude calls list_all_polymer_job_applications using the candidate ID to find the active application linked to the Senior Backend Engineer role. It extracts the job_application_id and the job_id.
3. Claude calls create_a_polymer_job_application_review using the job_application_id, formatting the hiring manager's raw text into a structured, professional review payload.
4. Claude calls list_all_polymer_job_hiring_stages using the job_id to read the state machine. It returns a summary to the manager, confirming the review was posted and listing the upcoming "Executive Fit" and "Offer" stages.

Workflow 2: Post-Interview Stage Progression and Communication Setup

A recruiter needs to advance a candidate after an internal debrief clears them for the final round.

"The panel approved Mark Johnson for the Director of Sales role. Please move his application to the 'Final Executive Interview' stage and add a comment tagging the hiring manager to schedule it."

Execution Steps:

1. Claude calls list_all_polymer_job_applications to locate Mark Johnson's application for the Director of Sales role and extracts the job_application_id.
2. Claude calls list_all_polymer_job_hiring_stages using the associated job_id. It searches the returned array for the stage named "Final Executive Interview" and extracts its unique UUID.
3. Claude calls create_a_polymer_job_application_stage_move passing the job_application_id and the extracted stage UUID.
4. Claude calls create_a_polymer_job_application_comment on the application, generating a note that says "Moved to Final Executive Interview per panel approval. @hiringmanager please initiate scheduling."

Security and Access Control

Providing an LLM with write access to your recruiting pipeline requires strict governance. Truto MCP servers enforce boundaries at the token level, ensuring agents only have access to exactly what they need.

• Method Filtering: You can configure the MCP token to restrict the agent to read-only operations. By passing methods: ["read"] during token creation, tools like create_a_polymer_job_application_stage_move are completely stripped from the server. The LLM cannot mutate data, even if explicitly instructed to do so.
• Tag Filtering: You can restrict the server to specific resource domains. By setting tags: ["applications"], the server will only expose tools related to job applications, entirely hiding global user directories or sensitive organizational settings.
• Require API Token Authentication: For internal deployments where the MCP URL might be exposed in logs or shared configs, you can enable require_api_token_auth. This forces the MCP client to pass a valid Truto API session token in the Authorization header, adding a mandatory secondary authentication layer beyond the URL token.
• Time-To-Live (TTL) Enforcement: You can append an expires_at datetime to the MCP token configuration. Truto will automatically clean up the edge storage records and revoke the access when the timestamp is reached, which is ideal for granting an agent temporary access for a specific audit or batch automation task.

Architecting for Agentic Recruiting

Connecting Polymer to Claude via MCP transforms your ATS from a static database into an active, programmable workspace. Instead of forcing recruiters to manually update stage dropdowns, upload feedback documents, and track UUIDs across different interface screens, your AI agents handle the API orchestration.

By leveraging Truto's managed MCP infrastructure, you skip the boilerplate of OAuth token refreshes, cursor-based pagination normalization, and dynamic tool generation. You simply connect the server, provide the natural language prompt, and let the agent navigate the Polymer pipeline natively.