Connect Archer to ChatGPT: Automate records and workflow actions
Learn how to connect Archer to ChatGPT using a managed MCP server. Execute advanced workflow transitions, manage records, and automate GRC tasks.
If you need to connect Archer to ChatGPT to automate risk management records, orchestrate compliance workflows, or track integration data feeds, you need a Model Context Protocol (MCP) server. This server acts as the translation layer between ChatGPT's JSON-RPC tool calls and Archer's highly specific REST and Content APIs. You can either build and maintain this translation infrastructure yourself, 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 Archer to Claude or explore our broader architectural overview on connecting Archer to AI Agents.
Giving a Large Language Model (LLM) read and write access to a highly configurable enterprise GRC platform like Archer is a massive engineering challenge. You have to handle complex nested payload structures, map dynamic integer-based field IDs to human-readable concepts, and manage strict advanced workflow transitions. Every time a developer adds a new application level or updates a field definition in Archer, your custom server code must adapt to the new schema.
This guide breaks down exactly how to use Truto to generate a secure, managed MCP server for Archer, connect it natively to ChatGPT, and execute complex compliance and risk workflows using natural language.
The Engineering Reality of the Archer 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 Archer's deeply structured API is exceptionally painful.
If you decide to build a custom MCP server for Archer, you own the entire API lifecycle. Here are the specific integration challenges that break standard CRUD assumptions when working with Archer:
The Dual API Dichotomy: Content API vs RESTful API
Archer exposes two primary ways to interact with records, and they behave entirely differently. The Content API (/contentapi/{level_alias}) relies on string-based aliases (e.g., Incidents_Risks) and is primarily used for querying data and simple creations. The RESTful API uses internal integer IDs (LevelId, FieldId, ContentId). An LLM needs to navigate both. It might search for a record using a human-readable level_alias via the Content API, but to update that record with strict type enforcement, it must switch to the RESTful API, requiring it to map those aliases back to internal integer IDs. Truto's MCP tools expose both paradigms cleanly, allowing the LLM to choose the right approach based on the operation.
The FieldContents Payload Complexity
When an LLM attempts to create or update a record via the RESTful API, a standard flat JSON object will fail. Archer requires a highly specific FieldContents object keyed by the internal Field ID. Worse, every value must be wrapped in a type definition. For example, updating a text field, a date field, and a cross-reference requires passing {"Type": 1, "Value": "Text", "FieldId": 123}, {"Type": 3, "Value": "12/31/2026", "FieldId": 124}, and {"Type": 9, "Value": [{"ContentID": 456}], "FieldId": 125} all in the same payload. If you build this yourself, you must parse the LLM's flat arguments into this nested, type-strict structure. Truto handles this schema mapping automatically via its proxy API layer.
Advanced Workflow Transitions
You cannot simply change the "Status" text field of an Archer record to move it to the next stage. Archer uses Advanced Workflows. To advance a record, the client must first query the available transitions for that specific record to obtain the current WorkflowNodeId and the specific CompletionCode for the desired path (e.g., "Approve" vs "Reject"). Only then can you POST a workflow action. Expecting an LLM to guess these node IDs is a guaranteed hallucination. Truto explicitly provides tools to list available actions and execute them, guiding the LLM through the state machine.
How to Generate an Archer MCP Server
To connect ChatGPT to Archer, you first need to generate an MCP server URL scoped to a specific authenticated Archer instance. Truto handles the OAuth/session lifecycle and exposes the server via a secure, unguessable token URL.
Method 1: Via the Truto UI
The fastest way to get started is generating the server directly from the dashboard:
- Navigate to the Integrated Accounts page and select your connected Archer instance.
- Click the MCP Servers tab.
- Click Create MCP Server.
- Configure the server. You can restrict the server to specific operations (e.g., only
readmethods) or specific tags (e.g.,records,workflows). - Click Save and copy the generated MCP server URL (it will look like
https://api.truto.one/mcp/a1b2c3d4...). Treat this URL as a secret.
Method 2: Via the Truto API
For production workflows, you will want to provision MCP servers programmatically for your users. You can do this by making a single POST request to the Truto API.
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 Archer Auditor",
"config": {
"methods": ["read", "write"],
"tags": ["records", "workflows", "data_feeds"]
}
}'The response will contain the secure url you need to pass to ChatGPT:
{
"id": "mcp_abc123",
"name": "ChatGPT Archer Auditor",
"config": { "methods": ["read", "write"] },
"expires_at": null,
"url": "https://api.truto.one/mcp/a1b2c3d4e5f6..."
}Connecting the MCP Server to ChatGPT
Once you have the Truto MCP server URL, you must register it with ChatGPT.
Note: Custom connectors via remote MCP require Developer mode, which is available on ChatGPT Pro, Plus, Business, Enterprise, and Education accounts.
Method A: Via the ChatGPT UI
- Open ChatGPT and navigate to Settings -> Apps -> Advanced settings.
- Toggle Developer mode to ON.
- Under MCP servers / Custom connectors, click to add a new server.
- Set the Name to something recognizable (e.g., "Archer GRC").
- Paste the Truto MCP URL into the Server URL field and click Save.
ChatGPT will immediately connect, perform the MCP handshake, and list the available Archer tools.
Method B: Via Manual Config File
If you are running a local desktop agent or configuring a headless LLM client that consumes standard MCP config files, you can map the Truto URL using the Server-Sent Events (SSE) transport.
Create or update your mcp.json configuration file:
{
"mcpServers": {
"archer_prod": {
"command": "npx",
"args": [
"-y",
"@modelcontextprotocol/server-sse",
"https://api.truto.one/mcp/a1b2c3d4e5f6..."
]
}
}
}Archer Hero Tools for ChatGPT
Truto dynamically generates tools based on the actual endpoints and schema available in the connected Archer instance. Here are the highest-leverage tools your AI agent will use to automate GRC workflows.
1. list_all_archer_records
Fetches a paginated list of records from a specific application level using the Content API. This is the primary discovery tool for finding target data. It uses string-based level aliases.
Usage note: Pass the alias exactly as it appears in Archer. For cross-references, you will get back linked record ID pairs instead of full object data.
"Find all open tickets in the Incidents_Risks level where the status is currently marked as Under Investigation. Fetch the first 50 records."
2. update_a_archer_record_by_id
Updates an existing record using the RESTful API. This is a targeted PUT request that only modifies the specific fields sent in the payload. It requires knowing the internal integer IDs for the level and the fields.
Usage note: The FieldContents object must be keyed by the Field ID, and each property must specify its numeric Type (e.g., 1 for Text, 8 for Users). Invalid field inputs are silently ignored by the Archer API, so the LLM must map the schema correctly.
"Update the risk severity on incident record ID 45992. Set the severity field (FieldId 882) to 'Critical'. Remember to wrap the value in the correct Type 4 Values List structure."
3. list_all_archer_workflow_actions
Retrieves the available advanced workflow transitions for a specific record. Because Archer records follow strict state machines, an LLM cannot guess what actions are currently allowed.
Usage note: The LLM must parse the response to find the WorkflowNodeId (located in the parent RequestedObject) and the CompletionCode for the specific transition it wants to execute.
"Check the available workflow transitions for vendor risk assessment record 10224. Tell me if the 'Submit for Approval' action is currently unlocked for this state."
4. create_a_archer_workflow_action
Executes a state transition on an Archer record. This moves the record forward in its defined advanced workflow path.
Usage note: This tool strictly requires the ContentId, CompletionCode, and WorkflowNodeId retrieved from the list_all_archer_workflow_actions tool. It will fail if the state has changed or the IDs are invalid.
"I need to approve the policy exception request. Take the CompletionCode for 'Approve' and the WorkflowNodeId from our previous check, and execute the transition on record 8831."
5. list_all_archer_data_feed_runs
Fetches the historical execution data for a specific integration Data Feed. Crucial for IT operations agents monitoring automated data imports from HRIS or vulnerability scanners.
Usage note: Requires the Data Feed's global GUID. Returns timestamps, status codes, and counts of records created, updated, or deleted during the run.
"Pull the run history for the Qualys Vulnerability data feed over the last 24 hours. Did any of the runs fail or report zero updated records?"
6. list_all_archer_data_feed_run_messages
Retrieves the detailed application logs for a single execution of a data feed. Used for deep debugging when a feed run reports an error status.
Usage note: You must pass the specific history_id obtained from the data_feed_runs tool.
"The last run of the Active Directory sync feed failed. Fetch the run messages for history ID 992841 and summarize the specific error codes causing the failure."
For the complete inventory of available Archer tools, schema definitions, and required parameters, visit the Archer integration page.
Workflows in Action
When you connect Archer to ChatGPT via Truto, the LLM can chain these tools together to execute complex, multi-step operations that would normally require manual clicks through the Archer interface.
Scenario 1: Automating Security Incident Escalation
An IT Security Analyst asks ChatGPT to escalate a critical finding and route it to the management queue.
"Find incident record 55219. Check what workflow actions are available. If 'Escalate to Tier 3' is an option, execute that transition. Then, update the incident's executive summary field to note that this was automatically escalated due to anomalous lateral movement."
Execution Steps:
get_single_archer_record_by_id: The agent fetches the current state of record 55219 to understand its baseline context.list_all_archer_workflow_actions: The agent queries the workflow engine for record 55219, parsing the response to find theWorkflowNodeIdand theCompletionCodespecifically for the "Escalate to Tier 3" transition.create_a_archer_workflow_action: The agent executes the transition, pushing the record to the next phase of the state machine.update_a_archer_record_by_id: Finally, the agent sends a PUT request targeting the executive summaryFieldId, wrapping the new string in aType: 1object to append the escalation note.
sequenceDiagram
participant Analyst as Security Analyst
participant ChatGPT as ChatGPT
participant TrutoMCP as Truto MCP Server
participant ArcherAPI as Archer REST API
Analyst->>ChatGPT: "Escalate incident 55219..."
ChatGPT->>TrutoMCP: Call list_all_archer_workflow_actions (id: 55219)
TrutoMCP->>ArcherAPI: GET /api/core/content/55219/workflow
ArcherAPI-->>TrutoMCP: Returns WorkflowNodeId & CompletionCodes
TrutoMCP-->>ChatGPT: JSON result
ChatGPT->>TrutoMCP: Call create_a_archer_workflow_action
TrutoMCP->>ArcherAPI: POST /api/core/content/workflow
ArcherAPI-->>TrutoMCP: 200 OK (Transition successful)
TrutoMCP-->>ChatGPT: Success confirmation
ChatGPT->>TrutoMCP: Call update_a_archer_record_by_id
TrutoMCP->>ArcherAPI: PUT /api/core/content/55219
ArcherAPI-->>TrutoMCP: 200 OK (Summary updated)
TrutoMCP-->>ChatGPT: Success confirmation
ChatGPT-->>Analyst: "Incident 55219 has been escalated and the summary is updated."Scenario 2: Data Feed Diagnostics
A Data Engineer notices that HR data isn't reflecting in Archer and asks the agent to investigate the integration pipeline.
"Check the recent runs for the Workday HR Sync data feed. If the latest run failed, pull the error messages and tell me exactly which records caused the batch to reject."
Execution Steps:
list_all_archer_data_feed_recent_runs: The agent queries the feed by its GUID to get the latest execution metadata. It identifies that the status is3(Failed) and extracts the specifichistory_id.list_all_archer_data_feed_run_messages: Using thathistory_id, the agent fetches the detailed application logs.- Analysis: ChatGPT parses the verbose log payload, identifies the specific XML parsing errors or missing mandatory fields causing the rejection, and generates a human-readable summary for the engineer.
Security and Access Control
Exposing an enterprise GRC platform to an AI agent requires strict guardrails. Truto's MCP servers provide granular access controls right at the token level, ensuring ChatGPT can only do exactly what you authorize.
- Method Filtering: Use
config.methodsto restrict the server entirely to safe operations. Settingmethods: ["read"]ensures the agent can query records and logs but is physically blocked at the proxy layer from executing creations, updates, or workflow transitions. - Tag Filtering: Use
config.tagsto limit the API surface area. For example, applying adata_feedstag ensures the server only exposes tools related to data feed monitoring, hiding all record manipulation tools from the LLM's context window. - Time-To-Live (TTL): Provision short-lived access by setting an
expires_attimestamp. Once the timestamp passes, Truto automatically destroys the token in the underlying KV store, immediately revoking ChatGPT's access to the Archer instance. - Layered Authentication: By enabling
require_api_token_auth, you force the MCP client to pass a valid Truto API token in theAuthorizationheader alongside the secure URL, ensuring that leaked URLs cannot be abused by unauthorized actors.
Handling Rate Limits and API Exhaustion
When writing automated workflows, it is critical to account for API rate limits. Truto does not retry, throttle, or apply automatic backoff on rate limit errors.
If ChatGPT executes a loop that triggers a HTTP 429 Too Many Requests error from the upstream Archer server, Truto passes that 429 error directly back to the LLM. However, Truto actively normalizes the upstream rate limit data into standardized headers (ratelimit-limit, ratelimit-remaining, ratelimit-reset) per the IETF specification.
This means the caller (or the agent orchestrating the calls) is fully responsible for reading these headers, pausing execution, and handling its own retry and backoff logic. Do not assume the integration layer will silently absorb API exhaustion.
Stop Writing Custom API Boilerplate
Connecting Archer to ChatGPT requires mapping complex, nested JSON objects, resolving internal integer IDs, and navigating a rigid workflow state machine. You can spend weeks building a custom MCP server to handle this translation layer, or you can generate one instantly.
Truto's dynamically generated MCP tools handle the heavy lifting of schema extraction, session management, and routing, giving your AI agents immediate, safe access to the data they need.
FAQ
- How does Truto handle Archer's dual API structure?
- Truto exposes tools for both the Content API (using string aliases for fast querying) and the RESTful API (using integer IDs and strict FieldContents structures for creation/updates), allowing the LLM to choose the right method for the task.
- Can I restrict ChatGPT to read-only access in Archer?
- Yes. When creating the MCP server in Truto, you can set the config methods to ["read"]. This ensures the LLM can only execute safe GET/LIST operations and is blocked from making POST/PUT updates.
- How does Truto handle Archer rate limits?
- Truto does not automatically retry or absorb rate limit errors. If Archer returns a 429 error, Truto passes it back to the caller, normalizing the rate limit info into standard IETF headers. The client is responsible for handling backoff.
- Does the LLM need to know Archer's internal Field IDs?
- Yes, when using the RESTful API tools for updates, the LLM must map values to specific integer Field IDs and wrap them in the correct Type definitions. Truto's schema documentation provides the context the LLM needs to format these payloads correctly.