---
name: adam-mcp
description: Connect this AI client to Adam MCP and carry out a supplied mechanical design or CAD workflow in the user's Adam workspace.
---

# Adam MCP

Connect to Adam, verify the workspace, then complete the user's supplied brief.
Keep that brief through sign-in and any client restart. This skill contains the
starter workflow; it does not require the separately packaged Adam plugin.

## Connect this client

Use `https://adam.new/mcp` with Streamable HTTP and OAuth. Inspect the existing
Adam connection first. When it is connected, call `adam_get_context` and proceed
to the workflow. Otherwise configure the current client below, preserving its
other MCP servers. Run setup commands only within the client's existing execution
permissions; do not replace a configuration file with the downloaded example.

- **Codex:** inspect `codex mcp list`. Add a missing server with
  `codex mcp add adam --url https://adam.new/mcp`, then run
  `codex mcp login adam`. In the desktop client without CLI access, add the same
  remote server in MCP settings.
- **Claude Code:** inspect `claude mcp list`. Add a missing server with
  `claude mcp add --transport http --scope user adam https://adam.new/mcp`.
  Open `/mcp`, select Adam, and authenticate.
- **Cursor:** merge the `adam` entry from the [server configuration](https://adam.new/developers/mcp/mcp.json)
  into `.cursor/mcp.json`, or `~/.cursor/mcp.json` for user-wide access. Enable
  Adam in MCP settings and authenticate.
- **Claude:** open Customize → Connectors and add a custom web connector named
  Adam with the server URL above. Choose OAuth and automatic client registration.
- **ChatGPT:** open Plugins → Add custom MCP server, name it Adam, enter the
  server URL above, and choose OAuth. Install the personal connection and sign in.
- **Grok:** open [Connectors](https://grok.com/connectors), choose New Connector
  → Custom, and add Adam with the server URL above. Complete Adam's OAuth
  sign-in. Business and Enterprise teams require an administrator to provision
  the connector first; see [Grok's connector guide](https://docs.x.ai/grok/connectors).
  In Grok Bot, ask the bot to add the Adam MCP server by URL and finish the
  in-chat Connect card's authentication, then resume the brief in your next
  message. See [Grok Bot's app guide](https://docs.x.ai/grok-bot/computer-and-apps).
- **Other MCP clients:** add a Streamable HTTP server at the same URL with OAuth
  and automatic client registration. Follow the client's setup controls.

The user completes Adam sign-in, chooses a workspace, and approves permissions
in the client/browser. Never ask for passwords, tokens, or API keys in chat.
If the host or workspace blocks MCP configuration, explain that restriction and
point to the [connection guide](https://docs.adam.new/mcp/connect); do not claim
the connection succeeded or bypass the restriction. Resume this same brief after
authentication or a required client restart.

Call `adam_get_context` to identify the selected workspace and granted scopes.
Direct execution needs `tasks:read`, `tasks:write`, and `tools:execute`; reading
or uploading files also needs the corresponding file permissions. Respect
workspace restrictions and the client's existing approvals. Engineering work
uses the workspace's existing Adam usage and billing; do not change its plan or
purchase credits as part of setup.

If the user only asked to connect, finish after verifying access. Do not create
a demonstration task. If a workflow brief was supplied, continue with it below.

## Complete the supplied brief

Use the real brief as the instruction, preserving requested units, dimensions,
materials, inputs, and output formats. Obtain missing source files or essential
constraints before starting. Reuse the current relevant task when continuing
work, and inspect its state before acting. Direct tools require a main task owned
by this user and project edit access when it belongs to a project; shared task
access alone is not sufficient.
For a revision in an existing task, inspect it with `adam_get_task`, inspect its
files with `adam_list_files`, then discover and call its tools; do not create
another task or send an agent message merely to record the revision. A task's
`idle` status does not prove direct tool calls have finished. Poll known call IDs
with `adam_get_tool_call`; when taking over without those IDs, confirm the prior
client has finished before starting conflicting work.

For new work driven by this client:

1. Upload required inputs with `adam_upload_attachment` using its exposed schema.
   Call `adam_create_external_task` with `prompt` set to the user's brief and a
   new `idempotencyKey`. Map the upload response's `upload.id` to
   `attachments: [{uploadId: upload.id}]` when needed. Use the creation response's
   `task.id` as `taskId` for the entire workflow. This creates an
   idle task without starting Adam's agent or provisioning compute.
2. Call `adam_list_task_tools` with `taskId`. Read the returned tool names,
   `inputSchema`, `available`, and `unavailableReason`. Discover and load the
   relevant CAD skill through these task tools before modeling. For STEP editing,
   the published `loadSkill` catalog ID is `cad-skills/cad`; discover that tool's
   schema before invoking it. If a required skill or tool cannot run, report the
   concrete prerequisite rather than inventing an operation.
3. Prefer Adam's sandbox CAD tools for a new file-based starter. Use a desktop
   integration when the brief calls for work in that application. MCP sign-in
   does not install or pair a CAD application. Confirm units and inspect the
   actual source file before editing. Use `adam_list_files({taskId})` to obtain
   persisted `file.id` and `file.name`, which differ from the temporary upload ID.
   Uploaded inputs are hydrated at `/home/adam/uploads/{file.id}/{file.name}`;
   task tools run from `/home/adam/workspace`. Verify the actual file with a
   discovered read/list tool and use its absolute path rather than a relative
   `uploads/` path or guessed filename.
4. Call `adam_call_task_tool` with `taskId`, the discovered `tool` name, its
   schema-valid `input`, and a new `idempotencyKey`. Poll `adam_get_tool_call`
   with that `taskId` and `callId` set to the response's `call.id` while status is
   `queued` or `running`.
   Inspect the result before dependent work. Reuse the same key and input for a
   retry of the same operation. An `unknown` outcome may already have taken
   effect: inspect the existing task, files, and document before deciding how to
   recover; do not automatically repeat it with a new key.
5. Preserve input files and save file edits as separate artifacts. Check requested
   dimensions, units, and solid validity using CAD tools. A screenshot alone is
   not a geometry check. For sandbox file deliverables or requested exports,
   publish the actual output path with the discovered `displayFile` tool and
   return its native file resources. A native CAD edit can finish in the saved
   native document; report that document's actual path and checks without
   requiring an unrequested export. Do not invent a download link or present an
   authenticated API `downloadUrl` as a public URL.

Use `adam_get_task` to inspect or poll the task. Use `adam_show_task` or
`adam_show_file` when the user asks to open or visually inspect the task or CAD
result. Keep further changes in the same task and wait for active work to finish
before starting a conflicting operation.

When the user explicitly asks Adam's agent to perform the work, use
`adam_list_models` and `adam_create_task` with the actual engineering brief and
a new `idempotencyKey`, then follow that task with `adam_get_task`. Do not ask
Adam to create another task. Use `adam_answer_interaction` for its outstanding
questions or approvals and `adam_send_message` to continue the same task.
`adam_send_message` starts Adam's agent. Do not use it merely to attach or log
client-driven work and then execute that work again through direct tools.