MCP and plug-ins

Run Adam tools from your AI clientBeta

Let a connected client run individual tools in an Adam task, follow durable results, and recover without duplicating work.

Your AI client can control individual Adam tools inside a task you own, including the named operations for supported connected CAD and CAE applications. The client inspects the application, performs your requested operation, reads the result, and decides the next step. Each direct tool call runs without starting an Adam agent loop, while the task keeps your brief, files, and history together.

To have Adam's agent plan and perform the work instead, delegate an Adam task.

Before you begin

Connect your client to the intended Adam workspace.
Grant tasks:read, tasks:write, and tools:execute for the full discovery, execution, and result-reading workflow. Add file or project permissions when those operations are needed.
Use a main task you own. A shared task you can view or edit is not sufficient for this direct execution path. If the task belongs to a project, you also need project edit access.
Confirm that your workspace allows API/MCP access and full execution, and that the requested operation has the required integrations, workstation, license, and Adam usage.

Start with discovery

Inspect tools without running them

In my Adam task [task ID], read the current state and list the available tools and their input requirements. Identify which tools could inspect [model or file] and any unavailable-tool reasons. Do not execute tools, create a new task, or start an Adam agent.

Both MCP endpoints advertise native application operations individually with their input schemas. The ChatGPT/Codex endpoint also advertises named sandbox command, file, skill, and documentation operations. Use the tools actually declared by your connection.

The general /mcp endpoint additionally offers adam_list_task_tools. This discovery returns tool names, input schemas, an available flag, and an optional unavailableReason. It does not run the tools or provision compute. An available tool still needs its application, credentials, runtime, and other prerequisites when executed. This generic discovery interface is not exposed by /mcp/chatgpt.

Connect to an engineering application

Check the relevant connection below. For a desktop connector, choose the intended computer from adam_list_devices. If more than one could match, choose the target before editing. Follow the application's connection guide when setup is incomplete.
Reuse your task or call adam_create_external_task with your actual design brief. Load the application's Adam skill before modeling or analysis.
Read the chosen operation's declared input schema. Desktop connector calls include deviceId; Fusion, Onshape, and Arena calls do not. Inspect the intended document and units before changing it.
Wait for each durable call's result before starting dependent work. For an application with runtime tool discovery, wait for its catalog result before choosing an operation and use that operation's returned schema.
Check the geometry or analysis in the application and save or export when requested. Use device file-transfer tools for paired desktop workflows and the application's own export operations for Fusion or cloud workflows.

An application launch is separate from inspecting the document. A ready launch response does not replace reading the intended document, units, and native application state. Native operations may change open models, run scripts or solvers, and overwrite files. A screenshot does not establish model validity or a completed solve.

Application coverage

Both /mcp and /mcp/chatgpt expose the following engineering routes:

Area	Applications	Direct tools
Live Fusion	Autodesk Fusion	`adam_fusion_read`, `adam_fusion_create`, `adam_fusion_update`, `adam_fusion_delete`, `adam_fusion_execute`
Cloud CAD	Onshape	Each registered operation as `adam_onshape_<operation>`, with its exact case-sensitive name and input schema
Mechanical CAD	SOLIDWORKS, Siemens NX, Inventor, Creo, CATIA V5, CATIA V6, Solid Edge, Rhino	Named operations from each connector's contracts
Simulation	SOLIDWORKS Simulation, Ansys Mechanical, Fluent, Workbench, Abaqus, COMSOL, LS-DYNA, STAR-CCM+, HyperMesh	Named operations from each connector's contracts
Simulation geometry	Ansys SpaceClaim and Discovery	Named operations from each connector's contracts
Electronics	Altium Designer and KiCad	Named operations from each connector's contracts
BIM and 3D	Revit, Blender, SketchUp, Unreal Engine	Application-specific `adam_<application>_list_tools` and `adam_<application>_run_tool`
Product lifecycle	Arena	Each registered operation as `adam_arena_<operation>`

Each integration exposes the operations Adam supports. Coverage does not establish that every application edition, license, or workflow is supported, or that a particular application is currently connected. Arbitrary custom MCP connectors are outside these application-specific adapters.

Fusion

Keep Fusion open with the intended design and its Adam panel signed into the same Adam account as the MCP connection. Read-only adam_fusion_status checks the live add-in connection without creating a task or running a CAD operation. Fusion does not use a paired-computer ID for direct operations.

A null connection from adam_get_integration is expected for Fusion: that generic field describes saved integration connections, while Fusion uses a live add-in session. Use adam_fusion_status for connectivity, then adam_fusion_read in your task to inspect the document. All five Fusion operations take {taskId, idempotencyKey, input} with their declared operation schema.

Onshape and Arena

Connect the requested cloud account in Adam Integrations and inspect it with adam_get_integration. These tools do not require a paired computer or a running desktop application. Each named operation takes {taskId, idempotencyKey, input}. For Onshape, identify the intended document, workspace or version, and element before editing; use the document selectors required by the operation's schema.

Paired desktop applications

Read-only adam_list_devices requires integrations:read and reports paired computers, reported application state, and publicTools. Use its returned computer ID as the deviceId for named connector operations: {taskId, idempotencyKey, deviceId, input}. Launch and file-transfer tools use input.device in their own declared schemas.

For Revit, Blender, SketchUp, and Unreal, the installed application server owns the tool catalog. Queue adam_<application>_list_tools with {taskId, idempotencyKey, deviceId} and poll its result. Then call adam_<application>_run_tool with {taskId, idempotencyKey, deviceId, tool, input}, using the exact returned tool name and input schema. Each adapter is fixed to that application; it is not an unrestricted connector dispatcher. Discovery and execution can consume Adam usage.

Run a controlled operation

Use Adam tools in the same task

Continue my Adam task [task ID] using its tools. First inspect the current task and files, then discover the current tool schemas. Use an available read-only operation to report the units and overall dimensions of [model]. Keep the source unchanged and save the findings in this task. Wait for each operation's result before deciding the next step.

For new work, the client can create a task with your design brief without starting Adam's agent. Creating that task does not select a model, perform inference, or provision compute. Subsequent tool execution may consume usage, and some tools can start additional work.

Tool sequence

Step	MCP tool	Required permissions
Identify the workspace	`adam_get_context`	An authenticated, allowed connection
Inspect paired computers and applications	`adam_list_devices`	`integrations:read`
Check Fusion's live add-in session	`adam_fusion_status`	`integrations:read`
Create a task for client-driven work	`adam_create_external_task`	`tasks:write`
Queue a named operation	The named native application or sandbox tool	`tasks:write` and `tools:execute`
Discover additional task tools on `/mcp`	`adam_list_task_tools`	`tasks:read`
Queue a discovered operation on `/mcp`	`adam_call_task_tool`	`tasks:write` and `tools:execute`
Read the operation's status and result	`adam_get_tool_call`	`tasks:read` and `tools:execute`
Inspect a child task started by a tool	`adam_get_subagent`	`tasks:read` and `tools:execute`

Use an existing task when continuing work. Pass the saved request as prompt when creating a new external task, then use the exact declared tool name and input schema. Do not create a new task for each operation. Native CAD work does not require delegating to an Adam agent when the needed named operation is available. Do not silently switch to delegation, a different application, or a file-based model when a required native operation is missing.

Creating an external task and queuing a tool call require an idempotencyKey. Use a new key for a new operation and reuse the same key and input when retrying that operation. Keep the returned tool-call ID to retrieve its outcome. The Adam task ID, tool-call ID, and any MCP Tasks transport handle are different identifiers. Direct calls are tracked with adam_get_tool_call, not MCP Tasks handles.

Read the result before continuing

Tool-call status	What to do
`queued` or `running`	Check the same call ID until it finishes.
`succeeded`	Inspect the output and generated files before starting dependent work.
`failed`	Read the returned error and check the affected document before retrying a possible change.
`unknown`	Treat the outcome as unresolved. The operation may have taken effect. Inspect the model, files, or child-task state; do not automatically repeat it with a new key.

Results can be truncated, and file access depends on the connection's permissions. Use returned file resources to open or download outputs. If a tool launched a child task, adam_get_subagent can look it up using the parent task and either the child task ID or the launch tool-call ID.

Continue with Adam's agent

Wait for active work to finish, then ask the client to send the next instruction to the same Adam task. Sending a message starts Adam's agent for that turn. After it finishes, your client can resume direct tools in the same task. Ask to show the task explicitly if you want its panel; polling its state does not open one.

Recover from access or execution errors

Execution tools are missing: inspect your granted scopes and the workspace's Allow full harness execution setting. Reconnecting cannot override an administrator's restriction.
Task not found or project access denied: verify the workspace, task ownership, and project edit access. Direct tools require a main task you own.
Work is already running: follow the existing operation instead of starting competing work in the same task.
An application is unavailable: use its connection guide. A tool's presence does not prove the native application is ready.
Usage or subscription is required: review billing and the operation's requirements. Inspect the existing call before submitting another.

For connection and rate-limit failures, see MCP troubleshooting.