# Run Adam tools from your AI client

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](/mcp/overview#delegate-an-engineering-task).

## Before you begin

- [Connect your client](/mcp/connect) 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.

`tools:execute` grants broad execution authority: commands, workspace files, connected accounts, paired devices, stored credentials, and billable tools. It is broader than the individual project, task, and file read/write permissions. Enable it for clients you intend to give that authority. Workspace owners and admins control it under **Admin > API & MCP > Allow full harness execution**.

## Start with discovery

```text
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

1. 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](/supported-software) when setup is incomplete.
2. Reuse your task or call `adam_create_external_task` with your actual design brief. Load the application's Adam skill before modeling or analysis.
3. 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.
4. 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.
5. 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

```text
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](/supported-software). A tool's presence does not prove the native application is ready.
- **Usage or subscription is required:** review [billing](/admin/billing) and the operation's requirements. Inspect the existing call before submitting another.

For connection and rate-limit failures, see [MCP troubleshooting](/mcp/connect#troubleshooting).