# Billing and usage
Source: https://docs.adam.new/admin/billing

Understand plan limits, shared balances, trials, subscription changes, invoices, and payment recovery.

Open your account menu, select **Settings**, and choose **Billing** to see your plan, usage, payment settings, and charge history.

Check the selected workspace first. Each workspace has its own subscription, included usage, and add-on balance. On a shared team, owners and admins manage billing; other members can view their usage.

See [Model usage costs](/admin/usage-costs) to understand how model families use your allowance.

## Compare plans

**Pro** and **Max** are individual plans. Both unlock Adam's paid model choices and refresh included usage each month. Max is designed for heavier or sustained workloads and includes more monthly usage than Pro.

**Team Pro** and **Team Max** add a shared workspace, shared files and integrations, per-member usage visibility, and owner-managed roles. Team plans are billed per seat. Each assigned member uses the monthly allowance from their own Pro or Max seat, and Team Max provides more monthly usage per seat than Team Pro. Add-on funds are shared across the workspace.

The comparison loads the current public plan catalog. Your existing plan, available changes, and renewal price appear in **Billing**. Review the checkout or change-plan screen for the price that applies to your account.

The **Free** plan includes a daily usage pool and access to Lite. **Enterprise** plans can be tailored for larger organizations that need custom usage, support, or administration. The usage and reload guidance below covers self-service plans. See [Managed Enterprise billing](#managed-enterprise-billing) if your organization has a managed plan.

## How usage refreshes

* Daily usage refreshes at **00:00 UTC**.
* Paid monthly included usage refreshes on the **first of each month at 00:00 UTC**. This is separate from the subscription renewal date shown in Billing.
* On a team plan, paid monthly usage belongs to the member assigned to that seat. Daily usage is also tracked separately for each member in each workspace.
* Add-on funds are shared across the workspace and keep paid models available after a member's monthly allowance is depleted.

Adam shows included usage as a percentage on the Billing page. A refresh renews the allowance; unused included usage does not accumulate. Trials use their own usage window, described under [Trials](#trials).

## After monthly usage runs out

When your paid monthly allowance and the workspace's add-on funds are depleted, Adam switches to a daily allowance for Lite:

* Adam's Pro and Ultra model families are unavailable for new messages until paid usage becomes available again. Connected Codex models have [separate usage rules](/admin/usage-costs#use-your-codex-plan).
* You can start tasks and continue existing tasks with Lite using a small daily allowance at no extra cost.
* Your daily allowance refreshes each day and remains available until your monthly allowance resets.
* The Billing page shows Daily usage first, followed by your depleted Monthly usage.

This fallback only changes model usage. You can still use other features included with your plan, such as projects, files, and integrations.

Adding funds makes paid models available again. Otherwise, wait for your monthly allowance to refresh on the first of next month. If the daily allowance is also depleted, Lite becomes available again after the next daily refresh.

## Keep using paid models

To restore paid model usage before the monthly refresh, you can:

* add funds to the workspace balance;
* turn on automatic reload; or
* upgrade to a plan with more monthly usage.

Otherwise, continue with Lite on your daily allowance or wait for the monthly allowance to refresh.

## Add-on funds and automatic reload

The **Usage-based balance** is prepaid money shared across the workspace. On a paid plan, it lets you continue after monthly usage runs out. Adding funds does not change your subscription or assign someone a different seat plan.

Use **Add funds** to make a one-time purchase. If no card is saved, choose **Add payment method** first. Saving a card does not itself buy funds or enable automatic reload.

Under **Usage-based balance**, choose **Set up**, or **Edit** if auto-reload is already enabled:

| Setting | What it controls |
| - | - |
| **When wallet balance falls below** | The balance that triggers a reload. Included monthly usage does not count toward this threshold. |
| **Reload back up to** | The target balance after the charge, not a fixed amount to add each time. |
| **Monthly limit (optional)** | A cap on automatic reload charges for the calendar month. Leave it blank for no cap. Manual **Add funds** purchases and subscription charges are separate. |

For example, with a \$10 threshold and a \$50 target, an \$8 balance needs a \$42 reload, subject to the remaining automatic-charge limit. Auto-reload can trigger even while included monthly usage remains.

When the automatic-charge limit is reached, reloads pause until the next month or until you raise the limit. You can still add funds manually. Choose **Edit** → **Turn off auto-reload** to stop future automatic reloads; this does not cancel your subscription.

> [!WARNING]
>
> Automatic reload charges the saved payment method. Review the target and monthly limit before turning it on. Check the charge history on the Billing page after a reload.

## Trials

When an eligible plan offers a trial, checkout shows its duration, price after the trial, and payment terms. Trial usage is limited separately from a full paid month. Crossing the first of the month does not refill an active trial.

If trial usage runs out, **Confirm subscription** starts the paid subscription early and charges your saved payment method immediately. The remaining monthly allowance unlocks after payment succeeds, and trial usage counts toward that first paid month's allowance. Confirming does not grant a second full allowance on top of what you already used.

If the payment is processing, use **Check payment**. If it fails, update your payment method in Billing and confirm again. To stop renewal, use the cancellation flow below before the trial ends.

## Manage the subscription

Open **Settings** → **Billing** → **Manage**:

| Action | Where to go |
| - | - |
| Change a plan or seat mix | **Manage subscription** |
| Open subscription invoices | **View invoice** |
| Replace the saved card | **Update payment method** |
| Review add-on purchases | Charge history under **Usage-based balance** |

### Plan and seat changes

Team workspaces can mix Pro and Max seats. Assign a plan to each teammate in the subscription dialog, review the total, and choose **Save seat plans**. Each person's included monthly usage stays separate; another member's unused allowance is not a shared pool. The usage-based balance is shared.

For subscriptions on the current billing system, an upgrade applies immediately and charges the full price difference for the billing interval, rather than a fraction based on days remaining. A lower-priced plan or seat mix takes effect at renewal; use the effective date shown in Billing. Upgrading during a trial can end the trial and charge the new plan immediately.

If Billing says your plan uses the previous billing system, its invoices and payment details open there. Changing to a different plan starts a new subscription on the current system and stops the old plan from renewing. Review that checkout before confirming.

### Cancel or reactivate

1. Open **Manage** → **Manage subscription** and choose **Downgrade to Free**.
2. Complete the cancellation flow. Cancellation is scheduled for the end of the current billing period, rather than ending access immediately.
3. Return to Billing and check the displayed expiry date. Choose **Reactivate** before that date if you want the subscription to continue.

Auto-reload is a separate setting. Turn it off as well if you want to stop future automatic add-on purchases.

To cancel a shared team's subscription, first reduce it to **one member and one seat**. The cancellation option is unavailable until both conditions are met. If a seat reduction is scheduled, check when it takes effect. Contact support if you need help coordinating the change.

### Payment problems

A **Payment past due** banner shows whether access remains available during a grace period or has been paused. Owners and admins can select **Resolve payment** to open billing recovery. A failed trial conversion without a previous successful plan payment does not receive the renewal grace period.

If auto-reload was disabled after a card decline, update the card and then turn auto-reload back on. If the page reports an unsupported payment method, contact support using the displayed error.

### Managed Enterprise billing

If Billing shows **Managed by** your organization, contact your Adam account manager for plan, invoice, seat, or workspace spending-cap changes. Self-service add-on funds and auto-reload do not apply to managed billing. When a managed allowance or cap blocks new work, follow the limit notice or contact your account manager; the self-service Lite fallback is not the recovery path for these plans.

## Get billing help

For a charge you do not recognize, include the workspace name, date, and receipt or charge identifier when emailing [hello@adam.new](mailto:hello@adam.new). Do not send full card details.


# Manage a team
Source: https://docs.adam.new/admin/team

Invite teammates, manage seats and roles, and understand the difference between team access and task sharing.

Every Adam account starts with a personal team. A shared team lets people work together with shared integrations, tasks, and files. Model usage follows the plan seat assigned to each member.

If you belong to more than one team, use the team switcher to choose where you want to work.

## Open team settings

Select your account menu, choose **Settings**, then open **Team**. The Team tab appears when you are in a shared team.

From Team settings, owners and admins can update the team, review seats, invite people, and manage members.

## Team roles

| Role | What they can do |
| - | - |
| **Owner** | Manage the team, members, seats, and billing. |
| **Admin** | Help manage members, seats, and billing. |
| **Member** | Use the team's tasks, files, and integrations. |

Only grant Owner or Admin to people who should manage team access and billing.

> [!NOTE]
>
> **Can view** and **Can edit** are task-sharing permissions, not team roles. A task can be shared with a specific person without changing their team role.

## Invite people and manage seats

**1. Review available seats**

Open **Settings** → **Team** and check the current seat count before inviting someone.

**2. Send an invitation**

Enter the person's email address and choose the appropriate team role.

**3. Track the invitation**

Pending invitations appear in Team settings. Invitations count toward seat capacity, so revoke an obsolete invite before reusing its seat.

**4. Review access after joining**

Confirm the member's role and remove connections or task shares they no longer need.

Team plans are billed per seat. Each assigned paid seat has its own monthly usage allowance, so adding a seat gives the assigned member their own included usage. Add-on funds remain shared across the workspace. See [Billing and usage](/admin/billing).

## Control API and MCP access

In a shared workspace, owners and admins can open **Admin > API & MCP** to manage external access:

* **Allow API and MCP access** controls whether members can create API keys and connect clients. Turning it off also stops existing credentials from accessing the workspace without deleting them.
* **Permissions members can grant** controls the read and write scopes available to new and existing connections.
* **Allow full harness execution** controls `tools:execute`, which permits direct commands and billable tools using workspace files, connected accounts, paired devices, and stored credentials.
* The API key and connected-app lists let administrators review and revoke members' credentials.

Members can review their own connections under **Settings > Developer > Connected apps**. See [MCP permissions](/mcp/tools) for the difference between resource access and direct execution. Reconnecting a client does not override a workspace restriction.

## Leave, delete, or remove access

Members can leave a team from Team settings. An owner can permanently delete an additional team from the danger zone after typing its name to confirm. Deleting a team cancels its active subscription and removes its tasks, files, invitations, and member access.

Your account's default team cannot be deleted separately because it holds your account-level workspace history. It is removed when you delete your account. Contact [hello@adam.new](mailto:hello@adam.new) if ownership of a team must change.

Before removing a member, review any tasks, published links, scheduled work, or integrations they manage.

## Share one task instead

If someone only needs access to a particular result, use task sharing instead of adding them to the whole team. Invite them with **Can view** or **Can edit**, or publish a read-only link. Learn more in [Work with tasks](/guides/workflows#share-a-task).


# Model usage costs
Source: https://docs.adam.new/admin/usage-costs

Understand how Adam's model families, Fast mode, and a connected Codex plan affect your usage allowance.

Adam's model picker groups models into Lite, Pro, and Ultra families, with a separate Codex section after you connect Codex. These are model choices, not subscription plans. Your plan determines which choices you can use and how much included usage you receive.

## Capability tiers

**Lite**, **Pro**, and **Ultra** are model families that let you choose based on the difficulty of the work. Each can contain several models, with one default used by the preset slider.

Choose a tier based on the work, not usage alone. Premium tiers use more of your allowance, but they are significantly more capable at 3D CAD modeling and complex engineering work. Reserve Lite for supporting tasks such as design reviews, straightforward edits, presentations, and bills of materials. Lite can handle limited 3D modeling, but use a premium tier when the CAD model itself is the main deliverable.

The comparison above uses each family's current default model and standard Fast rate. Other models in the same family can use different amounts of your allowance. On Max, Astra's lightning bolt uses Ultrafast at 6× the Standard rate.

## Choose a model within a family

Open **Advanced** → **Model** to see the available models grouped by family. Choose a model by name when you have a preference. All models within a family share its plan requirements and usage limits.

![Model picker with models grouped under Lite, Pro, and Ultra, and GPT 6 Astra selected in Ultra](https://mintcdn.com/adam-585915d9/dzd7_TgVZCSWXd5w/images/product/model-picker-families.png?fit=max\&auto=format\&n=dzd7_TgVZCSWXd5w\&q=85\&s=1d670feb13058eb5a5398e5a69a9bb2b)

Choose a model within Lite, Pro, or Ultra. The available models can change over time.

The picker button shows the family name by default. To show the selected model's name instead, turn on **Settings** → **General** → **Show model names**. Codex choices always show the model name.

If a model you selected is no longer available, Adam uses that family's current default model. If the family is no longer available to you, Adam uses the default for your plan.

## How models use your allowance

**What is Fast mode?** Fast mode increases how quickly supported model choices generate their output, so you spend less time waiting for a response. It costs more to run, which means Fast requests consume more of your usage allowance than Standard requests. Use the Fast toggle above to see the difference.

**What is Ultrafast?** Ultrafast runs GPT-6 Astra with faster response generation. It is available on Max plans, including Max seats in team workspaces, and uses six times the allowance of standard Astra at the same token count. On Max, select Astra and turn on the **lightning bolt** in the model picker to use Ultrafast. Other plans keep the existing Fast mode.

**What is large context?** Large context applies when a request contains enough instructions, conversation history, or file content to cross the large-context threshold. Affected models use more of your allowance beyond that point, which is reflected automatically in the tier comparison above.

**Token usage.** Requests use allowance for their input and generated output. A task can make several model requests as it reads files, calls tools, and works through the result. The comparison describes one request, not the total cost of a task.

The comparison shows uncached context and generated output for one request. Cached context can use less of your allowance. These are relative usage amounts, not subscription prices or separate charges.

Requests using Adam's model families consume included usage or add-on funds, depending on the remaining allowance.

Max includes more monthly usage than Pro, and Team Max includes more usage per paid seat than Team Pro. On team plans, each assigned member uses the monthly allowance for their own Pro or Max seat. Add-on funds are shared across the workspace.

After your monthly allowance and the workspace's add-on funds are depleted, Adam's model families fall back to Lite through a small daily allowance. Connected Codex models follow the rules below. See [Billing and usage](/admin/billing#after-monthly-usage-runs-out) for fallback behavior and refresh times.

### Other metered work

Image, video, music, and speech services requested by a task can also consume Adam usage. Model calls made through tools in the task environment are also metered. These costs are separate from the model comparison above and still apply when the main conversation uses a connected Codex model. Lite's daily fallback does not provide a separate media-generation allowance.

## Use your Codex plan

Under **Settings** → **General**, connect your Codex account. A separate Codex section then appears in the model picker, where you can choose from the models available through the connection. Model usage through that connection uses your Codex plan's allowance and does not reduce your Adam allowance. Separately metered services used by the same task can still consume Adam usage, as described above.

After you connect, Adam automatically selects the first available Codex model for new tasks. You can choose another Codex model or switch back to an Adam family from the same menu.

![Model picker with a separate Codex section below Lite, Pro, and Ultra, and GPT-5.6-Sol selected](https://mintcdn.com/adam-585915d9/dzd7_TgVZCSWXd5w/images/product/model-picker-codex.png?fit=max\&auto=format\&n=dzd7_TgVZCSWXd5w\&q=85\&s=57d4cab67bb6b5841f19cb9d6eadeb1c)

Connected Codex models appear in their own section below Adam's model families.

> [!NOTE]
>
> Connecting Codex and using Codex models requires a paid Adam plan. Your Codex plan's own usage limits still apply.


# Answer a task interaction
Source: https://docs.adam.new/api-reference/adam-api/answer-a-task-interaction

/openapi/v1.json post /v1/tasks/{taskId}/interactions/{interactionId}

# Cancel a task
Source: https://docs.adam.new/api-reference/adam-api/cancel-a-task

/openapi/v1.json post /v1/tasks/{taskId}/cancel
Cancels queued, running, or awaiting-input work. Repeated requests are safe; completed and failed tasks remain unchanged.

# Create a project
Source: https://docs.adam.new/api-reference/adam-api/create-a-project

/openapi/v1.json post /v1/projects

# Create an automation
Source: https://docs.adam.new/api-reference/adam-api/create-an-automation

/openapi/v1.json post /v1/automations
Recurring schedules require cron; one-time schedules require runAt; webhook automations require triggerEvent.

# Create and start a task
Source: https://docs.adam.new/api-reference/adam-api/create-and-start-a-task

/openapi/v1.json post /v1/tasks
Starts asynchronous work. Supplying attachments additionally requires files:write; each uploadId must come from POST /v1/uploads.

# Delete a project
Source: https://docs.adam.new/api-reference/adam-api/delete-a-project

/openapi/v1.json delete /v1/projects/{projectId}

# Delete a task
Source: https://docs.adam.new/api-reference/adam-api/delete-a-task

/openapi/v1.json delete /v1/tasks/{taskId}

# Delete an automation
Source: https://docs.adam.new/api-reference/adam-api/delete-an-automation

/openapi/v1.json delete /v1/automations/{automationId}

# Download a file
Source: https://docs.adam.new/api-reference/adam-api/download-a-file

/openapi/v1.json get /v1/files/{fileId}/content

# Get a project
Source: https://docs.adam.new/api-reference/adam-api/get-a-project

/openapi/v1.json get /v1/projects/{projectId}

# Get a task and its messages
Source: https://docs.adam.new/api-reference/adam-api/get-a-task-and-its-messages

/openapi/v1.json get /v1/tasks/{taskId}

# Get an automation
Source: https://docs.adam.new/api-reference/adam-api/get-an-automation

/openapi/v1.json get /v1/automations/{automationId}

# Get an integration
Source: https://docs.adam.new/api-reference/adam-api/get-an-integration

/openapi/v1.json get /v1/integrations/{integrationSlug}

# Get authentication context
Source: https://docs.adam.new/api-reference/adam-api/get-authentication-context

/openapi/v1.json get /v1/auth/context

# Get billing and usage summary
Source: https://docs.adam.new/api-reference/adam-api/get-billing-and-usage-summary

/openapi/v1.json get /v1/billing/summary

# Get file metadata
Source: https://docs.adam.new/api-reference/adam-api/get-file-metadata

/openapi/v1.json get /v1/files/{fileId}

# List a task's messages
Source: https://docs.adam.new/api-reference/adam-api/list-a-tasks-messages

/openapi/v1.json get /v1/tasks/{taskId}/messages
Returns messages in chronological order. Use nextCursor to continue from the last message in the page.

# List automations
Source: https://docs.adam.new/api-reference/adam-api/list-automations

/openapi/v1.json get /v1/automations

# List available and connected integrations
Source: https://docs.adam.new/api-reference/adam-api/list-available-and-connected-integrations

/openapi/v1.json get /v1/integrations

# List available models
Source: https://docs.adam.new/api-reference/adam-api/list-available-models

/openapi/v1.json get /v1/models

# List project files
Source: https://docs.adam.new/api-reference/adam-api/list-project-files

/openapi/v1.json get /v1/projects/{projectId}/files

# List projects
Source: https://docs.adam.new/api-reference/adam-api/list-projects

/openapi/v1.json get /v1/projects

# List task files
Source: https://docs.adam.new/api-reference/adam-api/list-task-files

/openapi/v1.json get /v1/tasks/{taskId}/files

# List tasks
Source: https://docs.adam.new/api-reference/adam-api/list-tasks

/openapi/v1.json get /v1/tasks

# Pause an automation
Source: https://docs.adam.new/api-reference/adam-api/pause-an-automation

/openapi/v1.json post /v1/automations/{automationId}/pause

# Resume an automation
Source: https://docs.adam.new/api-reference/adam-api/resume-an-automation

/openapi/v1.json post /v1/automations/{automationId}/resume

# Send a message to a task
Source: https://docs.adam.new/api-reference/adam-api/send-a-message-to-a-task

/openapi/v1.json post /v1/tasks/{taskId}/messages
Continues asynchronous work. Supplying attachments additionally requires files:write; each uploadId must come from POST /v1/uploads.

# Update a project
Source: https://docs.adam.new/api-reference/adam-api/update-a-project

/openapi/v1.json patch /v1/projects/{projectId}

# Update a task
Source: https://docs.adam.new/api-reference/adam-api/update-a-task

/openapi/v1.json patch /v1/tasks/{taskId}

# Update an automation
Source: https://docs.adam.new/api-reference/adam-api/update-an-automation

/openapi/v1.json patch /v1/automations/{automationId}

# Upload a project file
Source: https://docs.adam.new/api-reference/adam-api/upload-a-project-file

/openapi/v1.json post /v1/projects/{projectId}/files

# Upload a task attachment
Source: https://docs.adam.new/api-reference/adam-api/upload-a-task-attachment

/openapi/v1.json post /v1/uploads
Uploads bytes for a later task or message. The returned upload id is opaque, expires after 24 hours, and creates no durable file until referenced.

# Adam API overview
Source: https://docs.adam.new/api-reference/introduction

Build on Adam with OAuth, personal API keys, and the versioned REST API.

The Adam API lets you create projects, run AI engineering tasks, manage
automations, upload input files, and download the files Adam produces. The
production base URL is:

```text theme={null}
https://api.adam.new/v1
```

> [!WARNING]
>
> The Adam API is in beta. Backwards-compatible additions may ship within
> `/v1`; breaking changes use a new major path such as `/v2`. Adam announces
> removals at least 90 days in advance with `Deprecation` and `Sunset` response
> headers.

> [!NOTE]
>
> Connecting Claude, Codex, Cursor, or another AI client? Use the hosted [Adam
> MCP server](/mcp/overview) instead. It handles OAuth and exposes Adam as
> purpose-built tools.

## Authentication

Workspace owners and admins can disable API/MCP access or block individual permissions under **Admin > API & MCP**. These restrictions also apply to existing keys and OAuth connections. The separate `tools:execute` permission grants broad execution authority for [client-driven tool calls](/mcp/direct-tools); it is not implied by task or file write access.

Every API endpoint accepts either a personal API key or an Adam ID OAuth 2.0
access token.

### Personal API keys

Create a personal API key for the workspace you want to use. Adam shows the
secret once, so store it in a password manager or secret store. Send it as a
Bearer token on every request:

```bash theme={null}
curl https://api.adam.new/v1/projects \
  -H "Authorization: Bearer $ADAM_API_KEY"
```

Personal keys act as you and are restricted to the workspace and scopes chosen
when the key is created. Removing you from the workspace, revoking the key, or
deleting your account immediately invalidates it.

### OAuth

Installed apps and other public clients can use Adam ID's authorization-code
flow with PKCE (S256). The flow opens Adam in the user's browser to sign in,
choose a workspace, and approve scopes; the client receives an access token
without handling the user's password or a long-lived personal key.

Start discovery from the API's protected-resource metadata:

```text theme={null}
https://api.adam.new/.well-known/oauth-protected-resource/v1
```

The authorization server is `https://api.adam.new/auth`. Send the RFC 8707
resource indicator `https://api.adam.new/v1` on the authorization request and
every token request, including authorization-code exchanges and refresh-token
grants. A token issued for another Adam resource, including the MCP server,
cannot authenticate to the REST API. Request `offline_access` when the client
needs a refresh token.

Send the resulting access token using the same Bearer header:

```bash theme={null}
curl https://api.adam.new/v1/projects \
  -H "Authorization: Bearer $ADAM_ACCESS_TOKEN"
```

You can inspect the user, workspace, scopes, and credential type associated
with either credential:

```bash theme={null}
curl https://api.adam.new/v1/auth/context \
  -H "Authorization: Bearer $ADAM_API_KEY"
```

> [!WARNING]
>
> Never put a personal Adam API key in browser code, a mobile app, source
> control, or a client-side environment variable. Public clients should use
> OAuth with PKCE.

## Billing and integrations

Credentials with `billing:read` can retrieve a deliberately reduced subscription and
usage snapshot from `GET /v1/billing/summary`. The response includes the
effective plan, subscription state, renewal information, remaining usage
percentages, and top-up balance. It does not expose payment methods, Stripe
identifiers, raw credit accounting, or internal catalog IDs.

Credentials with `integrations:read` can list the integrations available to the
selected workspace with `GET /v1/integrations`, or inspect one by stable slug
with `GET /v1/integrations/{integrationSlug}`. Connection state reflects
workspace-wide connections and the authenticated user's own user-scoped
connections. Provider credentials, account metadata, and internal connection
identifiers are never returned.

## Automations

Use `automations:read` to list and inspect scheduled or webhook-triggered
automations. `automations:write` permits creation, editing, pausing, resuming,
and permanent deletion. Automation writes still enforce the same ownership,
workspace-role, subscription, trigger, and scheduling checks as the Adam app.

Recurring schedules require a cron expression; one-time schedules require an
ISO `runAt` timestamp. Webhook automations require a connected integration and
a provider trigger event. Responses use `effort` and omit internal model-tier
and provider-routing identifiers.

## Idempotent writes

Adam accepts an optional `Idempotency-Key` when you create a project or
automation and
requires it when you create a task, send a message, or answer a task
interaction. Use a new UUID for each logical operation and reuse it when
retrying that operation. Adam replays the original response when both the key
and request body match, and returns a conflict if the same key is reused for
different input. Results are retained for 24 hours; using the same key after
that window can execute a new request. Multipart uploads and task cancellation
do not use an idempotency key.

```bash theme={null}
curl https://api.adam.new/v1/projects \
  -X POST \
  -H "Authorization: Bearer $ADAM_API_KEY" \
  -H "Content-Type: application/json" \
  -H "Idempotency-Key: $(uuidgen)" \
  -d '{"name":"Gearbox redesign"}'
```

## Versions and limits

The major API version is part of the route. Compatible additions ship within
`/v1`; breaking changes will use a new major path such as `/v2` alongside the
old one.
When an endpoint or version is scheduled for removal, its responses carry
`Deprecation` and `Sunset` headers at least 90 days before the retirement
date, and the change is announced in the [changelog](https://adam.new/changelog).

Every request consumes from both a global per-credential bucket and a bucket for its
operation type. Responses include the selected policy in `X-RateLimit-Policy`
and describe both buckets:

Allowances are higher for workspaces with a paid subscription. These values are
loaded from Adam's current configuration; response headers remain authoritative
for an individual request.

| Header | Description |
| - | - |
| `RateLimit-Policy` | Standard advertisement of every applicable quota policy: capacity (`q`) and window seconds (`w`) |
| `RateLimit` | Standard live state of the most-constrained policy: remaining requests (`r`) and seconds until full (`t`) |
| `X-RateLimit-Limit` | Capacity of the selected operation policy |
| `X-RateLimit-Remaining` | Whole requests currently available under that policy |
| `X-RateLimit-Reset` | Unix timestamp when that policy bucket will be full again |
| `X-RateLimit-Global-Limit` | Capacity shared by all operations using the credential |
| `X-RateLimit-Global-Remaining` | Whole requests currently available globally |
| `X-RateLimit-Global-Reset` | Unix timestamp when the global bucket will be full again |

The buckets refill continuously, so remaining quota can increase before the
reset timestamp. If either bucket cannot accept a request, Adam returns `429`
with `Retry-After` set to the number of seconds until both buckets can accept
another request. `Retry-After` is omitted from successful responses.

All errors use one JSON shape and include a request ID you can send to support:

```json theme={null}
{
  "error": {
    "type": "invalid_request",
    "message": "Idempotency-Key header is required",
    "requestId": "019cf..."
  }
}
```

## Asynchronous tasks

Creating a task or sending a message starts work asynchronously. Poll the task
until its status is `completed`, `failed`, or `cancelled`. If the status is
`awaiting_input`, read `pendingInteraction` and answer it with the interaction
endpoint; Adam then continues the same task.

## Paginate collections

Projects, tasks, task files, project files, and task messages use opaque cursor
pagination. Set `limit`, then pass a non-null `nextCursor` back as `cursor` on
the next request. Do not decode cursors or reuse one with a different endpoint.

You can filter tasks by `projectId` or by one public status: `queued`,
`running`, `awaiting_input`, `completed`, `cancelled`, or `failed`.

## Delete projects, tasks, and project files

`DELETE /v1/projects/{projectId}` permanently deletes a project you own. Its
tasks and files survive and become ungrouped. `DELETE /v1/tasks/{taskId}`
permanently deletes an owned task and its message history. Both operations
require the corresponding write scope and cannot be undone.

`DELETE /v1/projects/{projectId}/files/{fileId}` removes a durable shared file
from that project and requires both `projects:write` and `files:write`. Task
files and message attachments are immutable because they form part of the task
history.

## Upload and attach files

Task attachments use a two-step flow. First upload the bytes with
`POST /v1/uploads`. The returned upload ID is valid for 24 hours and is bound to
the user and workspace represented by the credential.

```bash theme={null}
curl https://api.adam.new/v1/uploads \
  -X POST \
  -H "Authorization: Bearer $ADAM_API_KEY" \
  -F "file=@drawing.step"
```

```json theme={null}
{
  "upload": {
    "id": "adam_upload_...",
    "name": "drawing.step",
    "mediaType": "model/step",
    "size": 148320,
    "expiresAt": "2026-08-27T12:00:00.000Z"
  }
}
```

Reference that ID when creating a task or sending a message:

```bash theme={null}
curl https://api.adam.new/v1/tasks/$TASK_ID/messages \
  -X POST \
  -H "Authorization: Bearer $ADAM_API_KEY" \
  -H "Content-Type: application/json" \
  -H "Idempotency-Key: $(uuidgen)" \
  -d '{
    "content": "Check this drawing for manufacturing problems.",
    "attachments": [{"uploadId": "adam_upload_..."}]
  }'
```

Uploading and attaching files requires `files:write`. Creating a task or
sending its message also requires `tasks:write`. You can omit the text when the
attachment itself provides enough context.

To add a durable shared file directly to a project, send the multipart file to
`POST /v1/projects/{projectId}/files` instead.

## Read messages

Use `GET /v1/tasks/{taskId}/messages` for a paginated conversation. Messages
contain typed `parts`; there is no separate flattened text field.

```bash theme={null}
curl "https://api.adam.new/v1/tasks/$TASK_ID/messages?limit=50" \
  -H "Authorization: Bearer $ADAM_API_KEY"
```

```json theme={null}
{
  "messages": [
    {
      "id": "message-id",
      "role": "user",
      "createdAt": "2026-08-26T12:00:00.000Z",
      "parts": [
        {"type": "text", "text": "Check this drawing."},
        {
          "type": "file",
          "id": "file-id",
          "name": "drawing.step",
          "mediaType": "model/step",
          "downloadUrl": "https://api.adam.new/v1/files/file-id/content"
        }
      ]
    }
  ],
  "nextCursor": null
}
```

When `nextCursor` is not `null`, pass it as the next request's `cursor` query
parameter. File download URLs are absolute. You can also retrieve one file's
metadata with `GET /v1/files/{fileId}` before downloading its content.

The message-part types returned by an Adam deployment depend on its transparency
policy. Text, reasoning, and tool activity are enabled by default. Administrators
can also expose files, URL sources, document sources, reasoning files, structured
Adam data, provider-specific content, and model step boundaries. Disabled parts
are omitted; a message with no exposed parts is omitted as well.

Assistant tool activity remains in order. Every invocation has a `tool_call`
part. A completed invocation is immediately followed by a `tool_result` with a
`success`, `error`, or `denied` status.

```json theme={null}
[
  {
    "type": "tool_call",
    "toolCallId": "call-1",
    "name": "bash",
    "input": {"command": "python build.py"}
  },
  {
    "type": "tool_result",
    "toolCallId": "call-1",
    "name": "bash",
    "status": "success",
    "output": {"exitCode": 0, "stdout": "Created bracket.step"}
  }
]
```

Tool inputs and successful outputs are JSON values. Error results contain an
`error` string instead of `output`; denied results contain neither.


# Apply an operation across files
Source: https://docs.adam.new/cad/batch-operations

Run a reviewed export, drawing, or inspection procedure over an explicit set of models.

Batch work is useful for repeated exports, drawing updates, metadata checks, and design reviews. Start with a defined file list and an operation you have checked on a representative input.

## Define the batch

Specify the files or document links, configurations, source revisions, operation, destination, and naming convention. Decide how to handle existing outputs and which failures should stop the batch.

A folder name alone may be ambiguous. Ask Adam to enumerate the inputs before it starts, especially when subfolders or multiple configurations are involved.

```text title="Plan a STEP export batch" wrap theme={null}
List the native parts in [folder or document list] that you can access. Prepare a STEP export plan for configuration [name] of each part, using millimeters and [output folder]. Name outputs with part number and revision. Report missing references, unsaved documents, and destination collisions. Show the manifest before exporting.
```

## Check one result first

Run the operation on a representative file, then open its output. For geometry exports, verify scale, bodies, and configuration. For drawings, inspect all sheets and confirm the PDF reflects the intended source revision.

```text title="Run the checked export procedure" wrap theme={null}
Apply the export procedure we verified to the remaining files in the manifest. Preserve the source files and skip conflicting destination names. Return a per-file table with source revision, configuration, output path, verification performed, and success or failure. Keep failed items separate so we can retry only those after inspection.
```

## Handle interruptions

A timeout can occur after an application has already changed a file. Inspect the document and destination before retrying. Ask Adam to distinguish completed work, confirmed failures, and items whose state is uncertain.

Desktop batches require the paired computer and application to remain available. Solver or CAD session limits may mean work runs sequentially.

## Keep a reusable record

Retain the manifest, procedure, outputs, and exception report. Use [Repeat engineering work](/guides/repeatable-work) to preserve the brief and [Scheduled tasks](/guides/automations) when the work needs a recurring trigger.

For drawing batches, see [Engineering drawings](/cad/drawings). For a final handoff, see [Documentation and release](/cad/documentation-and-release).


# Prepare engineering documentation and release packages
Source: https://docs.adam.new/cad/documentation-and-release

Create work instructions, inspection records, and an organized handoff tied to the design revision.

Ask Adam to assemble the information someone needs to build, inspect, or review the design. Start from the intended audience and the controlled source files.

## Create work instructions

Provide the assembly, BOM, relevant drawings, sequence, tooling, and any approved process specifications. The model can show component relationships, but values such as tightening torque, adhesive cure time, and inspection limits need an authoritative source.

```text title="Draft an assembly instruction" wrap theme={null}
Draft an assembly instruction for [assembly], revision [revision], using the attached BOM and approved procedure. For each step, list the parts, orientation, tools, action, and inspection check. Use source images or CAD views where available. Cite supplied torque and process requirements; mark missing values for engineering input. Deliver an editable document and PDF.
```

## Prepare a release package

Define the required contents and file naming. A typical package may include the native model, exchange file, drawing PDF, BOM, revision summary, and review record. Your team's process determines what is required.

```text title="Assemble a reviewable release package" wrap theme={null}
Prepare a release package for [part or assembly], revision [revision]. Check that the native model, STEP, drawing PDF, and BOM refer to the same configuration and revision. Include a manifest and a list of open review items. Save the package in [destination] for review; leave lifecycle and approval states unchanged.
```

## Check consistency

| Item | Check |
| - | - |
| Model and exchange file | Matching configuration, units, geometry, and source revision |
| Drawing | Current intended references, readable sheets, and resolved review findings |
| BOM | Quantities, part numbers, revisions, and excluded or suppressed components |
| Instructions | Correct assembly sequence and sourced process requirements |
| Manifest | File names, revisions, purpose, and remaining exceptions |

For [Arena](/integrations/arena), name the exact item, revision, and requested record operation. Preparing files does not by itself release an item or approve a change. Keep your existing PLM and approval process as the authority for those states.

## Hand off the result

Open the exported files, check the manifest against the package, and assign the remaining review items. Preserve the reviewed source and final outputs together.

Related: [Drawing review](/cad/drawing-review), [Batch operations](/cad/batch-operations), and [Repeat engineering work](/guides/repeatable-work).


# Review engineering drawings
Source: https://docs.adam.new/cad/drawing-review

Find missing information, conflicting annotations, and mismatches between a drawing and its model.

Ask Adam to review a PDF, native drawing, or drawing-and-model pair. A PDF supports a review of visible content. A connected native drawing can provide additional evidence about dimensions, model references, and revision state where the integration exposes it.

## Give the review a scope

Attach all sheets and identify the revision. Include the matching model when you want geometry checked, and provide the relevant house rules or supplier checklist. State which standard and edition apply if the review depends on them.

```text title="Review a supplier drawing package" wrap theme={null}
Review the attached drawing and STEP for the enclosure base, revision C. Use our attached checklist. Check whether the drawing defines the envelope, wall thicknesses, mounting pattern, and connector cutout; compare measurable dimensions with the model. Check units, title-block fields, duplicate or conflicting dimensions, and unreadable annotations. Return findings by sheet and feature with evidence, severity, and a proposed correction. Separate confirmed mismatches from questions.
```

## Inspect three kinds of finding

| Finding type | Example | Useful next action |
| - | - | - |
| Confirmed discrepancy | A measured hole location differs from its dimension | Establish the authoritative revision and correct the source |
| Missing requirement | A mating bore has no supplied fit requirement | Ask the designer for the functional fit |
| Review concern | Two leaders appear to overlap in the PDF | Inspect the sheet at readable scale and adjust layout |

Avoid treating every concern as a defect. An absent tolerance can be covered by an applicable general note, and a deliberately pinned model revision may be correct for an already released drawing.

## Compare revisions

```text title="Check what changed between revisions" wrap theme={null}
Compare revisions B and C of this drawing. List changed dimensions, tolerances, notes, and model references with sheet locations. Check whether the revision description accounts for those changes. Flag anything you cannot compare reliably, including unreadable or raster-only details.
```

For native drawings, ask Adam to check source-reference freshness before refreshing anything. Updating a reference can change dimensions; review the resulting sheet and annotations again.

## Close the review

After corrections, repeat the relevant checks on the final native drawing and exported PDF. Ask for the findings list with resolved items, remaining questions, and evidence for each resolution.

The result is a scoped engineering review. Approval follows your team's checking and release process. Continue with [drawing creation](/cad/drawings) or [documentation and release](/cad/documentation-and-release).


# Build a model from a drawing
Source: https://docs.adam.new/cad/drawing-to-model

Reconstruct an editable part from dimensioned views while keeping uncertain geometry explicit.

Attach a drawing and ask Adam to reconstruct the part in your chosen CAD application. This works best when the views, dimensions, and sections define the geometry clearly. Missing information should become a question or labeled assumption.

## Prepare the source

Use the clearest PDF or image available, including all sheets and section views. Identify units, revision, projection convention, and the target CAD application. If you have DXF or DWG files, ask Adam to check whether the available tools can read their entities; a readable PDF can provide additional reference.

## Reconstruct in stages

**1. Read the drawing**

Ask for a feature inventory and a list of dimensions that define each feature. Resolve conflicting or unreadable callouts.

**2. Plan the model**

Choose a base feature and a sequence of sketches, extrusions, cuts, and patterns appropriate to the part. Identify which values should become parameters.

**3. Build and compare**

Create the model, then check measured dimensions against the source. Compare orthogonal and section views where relevant.

**4. Deliver the reconstruction**

Request the editable source, exchange format, dimension comparison, and unresolved assumptions.

```text title="Reconstruct a stepped spacer" wrap theme={null}
Reconstruct the stepped spacer in this drawing in [CAD application], using millimeters. First list the diameters, axial lengths, bore, and edge features with their source callouts. Ask about missing values that determine the shape. Build a parameterized model, then compare each stated dimension with the finished geometry. Return the native model, STEP, and a dimension-check table.
```

## Handle incomplete information

Do not use a printed view's apparent size as an exact dimension unless the scale and measurement method are established. A scan can be distorted, and an isometric view can hide depth or internal details.

```text title="Resolve an ambiguous feature" wrap theme={null}
The bore termination is unclear in this drawing. Show which views or callouts support a through-hole or a blind hole, and identify the missing dimension. Pause that feature until I confirm its geometry.
```

A reconstruction may match the supplied dimensions without proving the original design intent. Keep assumptions with the model and use [drawing review](/cad/drawing-review) before producing a new manufacturing drawing.


# Create engineering drawings
Source: https://docs.adam.new/cad/drawings

Turn a CAD model into a drawing with a deliberate view and dimension plan.

Give Adam the source model and the information a fabricator or inspector needs. Drawing creation depends on the CAD application and available tools; Onshape and SOLIDWORKS have dedicated drawing workflows. For other applications or attached files, ask Adam to confirm the authoring and export path first.

Working from an uploaded STEP file? Ask for a dimensioned PDF and its generation source. If you need a native drawing document, specify the connected CAD application and have Adam confirm that it can author the required views and annotations there.

## Prepare the inputs

Provide the part or assembly and configuration, sheet template if you use one, units, projection convention, and required output formats. Include the material, finish, drawing number, revision, and tolerance policy where known.

Geometry defines nominal shape. Functional fits, threads, surface finishes, and tolerance requirements need supplied engineering intent.

## Work through a drawing

**1. Plan the views and dimensions**

Ask Adam to inventory the features and propose views that describe them clearly. Include sections or details for internal or crowded geometry.

**2. Create the drawing**

Use the agreed sheet, template, projection convention, and scale. Add dimensions tied to the model where supported.

**3. Check coverage and layout**

Compare the sheet against the model feature by feature. Check dimension values, references, notes, and readability.

**4. Deliver the editable drawing and PDF**

Export after the final changes and inspect every sheet. Retain a list of missing inputs or unresolved annotations.

```text title="Draft a drawing of a mounting plate" wrap theme={null}
Create a drawing for the active mounting plate, configuration [name], using our attached template. Use millimeters and the template's stated projection convention. First propose the views and a dimension plan covering the envelope, thickness, hole sizes, and hole locations. Apply the tolerance policy in the attached brief. Leave missing material or finish requirements unresolved. Create the native drawing and PDF, check each sheet for overlaps, and report any undimensioned features.
```

## Refine a specific area

```text title="Make a crowded detail readable" wrap theme={null}
The slot dimensions on sheet 1 are crowded. Add an appropriate detail view, move the relevant annotations to it, and keep their model references intact. Check the displayed values and units after the edit, then export a fresh PDF.
```

## Review the deliverable

| Check | Evidence to inspect |
| - | - |
| Source identity | Correct part, configuration, and revision |
| Feature coverage | Every required feature has an unambiguous size and location |
| Dimension meaning | Measured values, units, tolerances, and model attachments agree |
| Notes and metadata | Supplied material, finish, revision, and drawing number are present |
| Layout | Readable views and annotations on every exported sheet |
| Open issues | Missing intent and unsupported annotations are listed explicitly |

Use [Drawing review](/cad/drawing-review) for a separate checking pass before handing the drawing off for approval.


# Review manufacturing and assembly
Source: https://docs.adam.new/cad/manufacturing-review

Check a design against its process, material, supplier constraints, and assembly requirements.

Tell Adam how the part will be made. A useful review connects a measured feature to an applicable manufacturing rule and a practical change.

## Provide process context

Include the CAD file and revision, units, material, process, expected quantity, and supplier guidance. If you only have an image, Adam can identify visible concerns, but dimensional findings need geometry or supplied measurements.

| Process | Useful review topics |
| - | - |
| CNC machining | Tool access, internal radii, deep pockets, thin walls, setups, and workholding |
| Sheet metal | Thickness, bend geometry, reliefs, hole-to-bend relationships, and flat-pattern assumptions |
| Injection molding | Pull direction, draft, undercuts, wall transitions, and parting strategy |
| Assembly | Insertion direction, fastener access, locating features, clearances, and service access |

Use the supplier's limits when available. A general guideline does not establish the capability of a particular machine, tool, mold, or material.

## Request a measured review

```text title="Review a machined enclosure base" wrap theme={null}
Review this enclosure base for CNC machining in [alloy] using the attached supplier guidelines. Check pocket access, internal radii, wall thickness, and likely setups. For each finding, identify the feature, measured value and units, applicable rule and source, and suggested change. Mark any check that cannot be measured as unverified. Preserve the gasket land, mounting holes, and connector interface.
```

## Turn findings into a design change

```text title="Address a specific manufacturing finding" wrap theme={null}
Apply the proposed change for finding 2 to a copy of the native model. Preserve the protected interfaces from the brief. Rebuild the model, measure the changed feature, and recheck adjacent walls and clearances. Return the revised model and a before-and-after findings table.
```

For assembly review, include neighboring parts and the intended assembly sequence. A part in isolation cannot establish tool access or a complete clearance stack.

## What the report should contain

Ask for the reviewed revision, process assumptions, measured findings, rule sources, proposed actions, and checks that remain unavailable. Use pass/fail only where the measured value can be compared with a relevant requirement; qualitative concerns should remain review items.

If a change affects strength or stiffness, follow with [structural analysis](/cae/structural-analysis). For fit variation, use [Tolerance analysis](/cad/tolerance-analysis).


# Use a mesh as a CAD reference
Source: https://docs.adam.new/cad/mesh-to-cad

Plan a reconstruction from STL or mesh data and check how the fitted geometry differs from the source.

A scan or STL captures a surface approximation. Rebuilding it as CAD requires choices about planes, cylinders, symmetry, dimensions, and which details should be preserved.

Ask Adam to inspect the file and propose a reconstruction path supported by your CAD tools. Mesh inspection and repair do not by themselves produce an editable feature tree.

## Define the result you need

Provide the source mesh, units, known measurements, and intended use. Say whether you need a cleaned mesh, a reference model, fitted solid geometry, or an editable parametric reconstruction. For point clouds or proprietary scan formats, first check whether the task's tools can read them; request a supported export when necessary.

## Inspect before rebuilding

```text title="Plan a reconstruction from an STL" wrap theme={null}
Inspect this STL of a mounting adapter. Its measured overall length is [value] mm. Check scale, orientation, disconnected regions, and missing surface areas. Identify which planes and cylindrical features can reasonably be reconstructed in [CAD application]. Propose a feature plan and list details that need additional measurements before modeling.
```

Separate scan artifacts from intentional features. A notch could be damage, missing scan coverage, or a functional detail; the mesh alone may not resolve it.

## Reconstruct and compare

```text title="Rebuild the agreed features" wrap theme={null}
Reconstruct the agreed base, mounting holes, and cylindrical boss as editable features. Use the supplied measurements for the interfaces. Keep the original mesh as a reference and record any smoothing or omitted detail. Compare the resulting CAD surface with the mesh where the tools support it, reporting the method, units, and regions that remain uncertain.
```

## Review the output

Check dimensions at the mounting interfaces, body validity, surface coverage, and the deviation of fitted features. A global average error can hide a large local mismatch at a critical surface.

Keep the original scan, fitted model, measured references, and comparison together. If the result is an approximation, label it accordingly. For dimensioned drawings, use [Drawing to model](/cad/drawing-to-model); for simulation, review simplifications in [Geometry preparation](/cae/geometry-preparation).


# Create and change CAD models
Source: https://docs.adam.new/cad/modeling

Describe a part or modification, preserve design intent, and verify the resulting geometry.

Ask Adam to build a part from requirements or change an existing model. Use a [CAD connection](/supported-software) when the result needs to live in your application, or specify the source and exchange formats you want from an attached-file task.

## Before you start

Name the application and document, confirm the units, and describe the function. For an edit, identify the configuration and the dimensions, mounting points, or mating faces that must stay fixed.

A parametric part, an imported solid, and a mesh offer different editing options. Ask Adam to inspect the source before choosing how to modify it.

## Create a part

```text title="Create a parametric sensor mount" wrap theme={null}
In [CAD application], create a sensor mounting plate in millimeters: 76 mm long, 38 mm wide, and 5 mm thick. Add two 6.5 mm through-holes centered across the width, each 12 mm from its nearest short edge. Name the length, width, thickness, hole diameter, and end offset parameters. Keep the sketches constrained. Save the editable model and a STEP export, then report the measured envelope and hole-center spacing.
```

This request defines measurable geometry. Add material, load, manufacturing, and clearance requirements when the part has to satisfy them.

For this example, check the finished part against these measurements from the brief:

| Check | Expected value |
| - | - |
| Envelope | 76 × 38 × 5 mm |
| Through-holes | Two, each 6.5 mm in diameter |
| Hole-center spacing | 52 mm, calculated as 76 − 12 − 12 |
| Hole-center location across the width | 19 mm from either long edge |

Open the STEP export as well as the native document. If it contains only a mesh or the wrong configuration, ask Adam to correct the export before continuing.

## Change an existing part

**1. Inspect the starting point**

Confirm the intended document and configuration. Check the existing feature tree, geometry, and rebuild state.

**2. Describe the change and protected geometry**

Reference a feature, dimension, selection, or mating surface. State the intended value and unit.

**3. Rebuild and inspect**

Ask Adam to read back changed dimensions, inspect affected neighbors, and report new warnings or failures.

**4. Save the result**

Specify the destination and export format. Keep a recoverable source revision when comparing alternatives.

```text title="Change one parameter while preserving the interface" wrap theme={null}
In the open mounting plate, increase thickness from 5 mm to 7 mm. Preserve the bottom mounting face, outline, hole diameters, and hole-center locations. Update the thickness parameter where the model supports it, rebuild, and verify those protected dimensions. Save a new revision and return the native model plus STEP.
```

## What to review

Check the requested dimensions, number of bodies, hole and slot locations, and rebuild warnings. For an assembly, also check component positions and mating relationships. A screenshot helps explain the change; measurements establish whether it matches the request.

STEP can exchange solid geometry but generally does not preserve the original feature history. If you need editable sketches and features, request and inspect the native document as well.

Next: [make a drawing](/cad/drawings), [review manufacturability](/cad/manufacturing-review), or [repair a failed feature](/cad/repair).


# CAD workflows
Source: https://docs.adam.new/cad/overview

Go from a design request to an editable model, checked drawing, or engineering handoff.

Use Adam with a connected CAD application when you want to work in its native document. You can also attach files for review or ask Adam to generate a model in its task environment. Tell Adam which application and output format you need so it can check the appropriate tools before starting.

## Choose the job

> [card] [Modeling](/cad/modeling)
>
> Create geometry, change parameters, and preserve mating interfaces.

> [card] [Engineering drawings](/cad/drawings)
>
> Plan views, add dimensions, and deliver a drawing for review.

> [card] [Drawing review](/cad/drawing-review)
>
> Check coverage, readability, and agreement with the source model.

> [card] [Manufacturing review](/cad/manufacturing-review)
>
> Review machining, molding, sheet metal, and assembly concerns.

> [card] [Tolerance analysis](/cad/tolerance-analysis)
>
> Trace a dimension chain and calculate a functional gap or fit.

> [card] [Drawing to model](/cad/drawing-to-model)
>
> Reconstruct geometry from dimensioned views and sections.

> [card] [Mesh to CAD](/cad/mesh-to-cad)
>
> Use a mesh as a reference and distinguish fitted geometry from measurements.

> [card] [Batch operations](/cad/batch-operations)
>
> Apply a reviewed operation to an explicit list of files.

> [card] [Repair a model](/cad/repair)
>
> Find the first failing feature or reference and check the repair.

> [card] [Documentation and release](/cad/documentation-and-release)
>
> Assemble instructions, review records, and a traceable handoff.

## Give Adam the design intent

A shape alone rarely captures the whole requirement. Include dimensions and units, manufacturing process, material, interfaces that must stay fixed, and the output you expect. For an existing design, identify the document, configuration, and revision.

```text title="Start with an inspection of the current design" wrap theme={null}
Inspect [document] in [application]. Summarize its parts, key parameters, units, and any existing rebuild errors. I want to [design goal]. Identify the interfaces that should stay fixed and propose the smallest useful change. Ask about requirements you cannot establish from the model.
```

## Check the outcome

Ask for the editable source, any required exports, and a short verification summary. The summary should say what changed, which dimensions or interfaces were checked, and what remains unresolved. Review the native model and exported file together when both will be used downstream.

If you need loads, stresses, or fluid behavior rather than geometry checks, continue with [simulation workflows](/cae/overview).


# Diagnose and repair a CAD model
Source: https://docs.adam.new/cad/repair

Find the cause of rebuild failures, missing references, and assembly problems before changing the design.

Start from the first failing feature or missing reference. Later errors may be consequences of that failure, so repairing them individually can create unnecessary changes.

## Capture the failure

Provide the application, document, configuration, recent change, and error text. Include a screenshot if it shows the feature tree or problem area. Keep a recoverable copy or revision of the model.

```text title="Diagnose a failed rebuild" wrap theme={null}
Inspect the rebuild errors in [document] after the [recent change]. Identify the earliest failing feature and its missing or invalid inputs. Explain which later failures depend on it. Propose a repair that preserves the mounting interfaces and design intent, and identify any reference that cannot be matched unambiguously.
```

## Apply a focused repair

**1. Confirm the cause**

Check whether the problem is a missing source, changed topology, conflicting constraint, or invalid geometry.

**2. Repair the smallest affected area**

Restore or replace the intended reference, correct the parameter, or revise the feature. Rebuild after the change.

**3. Inspect downstream effects**

Check dependent features, dimensions, assembly relationships, and drawings. A cleared error icon is only one part of the check.

```text title="Verify a repaired reference" wrap theme={null}
After repairing the sketch reference, rebuild the complete model. Check the original hole locations, overall dimensions, and affected assembly relationships. Report any remaining suppressed or failed features, then update the working copy and provide a change summary.
```

## Common recovery paths

| Symptom | Start by checking |
| - | - |
| Missing external reference | Source availability, file path, permissions, and revision |
| Failed fillet or shell | Changed neighboring geometry, radius or thickness, and the first failing feature |
| Overconstrained sketch | Conflicting dimensions, constraints, and intended degrees of freedom |
| Mate conflict | Component positions, replaced geometry, and the intended assembly relationship |
| Broken drawing reference | Source document, configuration, part identity, and drawing revision |

If an operation was interrupted, ask Adam to inspect the current state before repeating it. For connectivity problems, use [Troubleshooting](/resources/troubleshooting). For drawing checks after a repair, see [Drawing review](/cad/drawing-review).


# Analyze tolerances and fits
Source: https://docs.adam.new/cad/tolerance-analysis

Define a functional dimension, trace its contributors, and calculate the range implied by supplied tolerances.

Ask Adam to build a calculation from your drawings, dimensions, and assembly intent. Start with the functional question: a clearance, alignment, engagement, or interference that must remain within a specified range.

Adam can help organize the chain and calculate its variation. Completeness of the chain and interpretation of geometric tolerances still require engineering review.

## Define the chain

Provide the relevant parts and revisions, dimension sources, tolerance limits, datum references, and operating conditions. Explain which surfaces contact or locate each other.

```text title="Calculate an axial clearance" wrap theme={null}
Calculate the axial clearance in the attached housing assembly. Trace the chain from the internal shoulder to the retaining face, using the supplied drawings and revisions. Show the signed dimension equation, nominal values, limits, and source callout for every contributor. Calculate the worst-case clearance and compare it with our required range of [minimum] to [maximum] mm. List missing dimensions or assumptions before giving a conclusion.
```

## A simple worked example

Suppose a housing length is **42.00 ± 0.08 mm** and two captured components are **17.00 ± 0.03 mm** and **24.50 ± 0.04 mm**. For the stated one-dimensional chain:

* Nominal clearance: 42.00 − 17.00 − 24.50 = **0.50 mm**.
* Minimum: 41.92 − 17.03 − 24.54 = **0.35 mm**.
* Maximum: 42.08 − 16.97 − 24.46 = **0.65 mm**.

This illustrative calculation covers those three contributors only. It does not include unmodeled contact effects, thermal growth, geometric variation, or other parts.

## Choose the analysis method

Use worst-case bounds when you need the extremes allowed by the specified dimension limits. Statistical analysis needs justified distributions, centering, and dependence assumptions. Tolerance half-widths are not automatically standard deviations.

```text title="Review whether a statistical estimate is appropriate" wrap theme={null}
Review whether a statistical stack-up is justified for this chain. Identify the distribution and process data needed for each contributor and any correlated dimensions. If the evidence is insufficient, keep the worst-case calculation and list the missing information instead of assuming independent normal distributions.
```

## Review and deliver

Ask for a table of contributors, the equation, calculation method, range, dominant contributors, and assumptions. For GD\&T, ensure the chosen interpretation matches the supplied standard, datum scheme, and material conditions.

Use [drawing review](/cad/drawing-review) to check the source annotations, and [modeling](/cad/modeling) when a design change is needed.


# Run a fluid analysis
Source: https://docs.adam.new/cae/fluid-analysis

Define a fluid domain and operating conditions, then evaluate flow and pressure results.

Ask Adam to prepare or inspect a CFD case for a specific engineering question. State whether you care about pressure drop, flow distribution, aerodynamic force, cooling, or another output.

## Define the operating point

Provide the geometry revision and length units, fluid properties and their source, flow rate or other driving conditions, pressure reference, and output locations. Specify heat sources and thermal boundaries when temperature matters.

The model must distinguish internal or external flow, laminar or turbulent behavior, steady or transient behavior, and any compressibility or multiple regions required by the case.

```text title="Set up an internal-flow comparison" wrap theme={null}
Compare pressure drop through the attached duct revisions A and B at the same specified volumetric flow rate of [value and units]. Use [fluid] at [temperature] with sourced properties. Identify inlet and outlet measurement planes, construct the fluid region, and justify the flow model from the operating conditions. Check the available solver, propose a mesh and convergence plan, and keep the physical conditions fixed between revisions.
```

## Check the case before running

Confirm the mesh occupies fluid space and that inlet, outlet, wall, and interface regions survived export. Inspect pressure and velocity conventions, backflow settings, wall treatment, and thermal conditions where relevant.

```text title="Inspect boundary assignments" wrap theme={null}
Inspect this CFD case before running. List every mesh boundary and its velocity, pressure, turbulence, and thermal conditions where applicable. Confirm the fluid region, length scale, pressure convention, and total inlet flow. Identify missing or conflicting conditions and explain the expected direction of flow.
```

## Monitor the engineering quantity

Track the requested pressure drop, force, or temperature during the run, alongside solver diagnostics. Check mass balance and, for thermal cases, the relevant energy balance. Evaluate sensitivity to mesh, domain size, and time step as appropriate.

A residual threshold alone does not establish a stable engineering result. For transient flow, define the averaging interval and explain how startup behavior is handled.

## Deliver useful results

Request the native case, mesh and settings, logs, raw fields, and a table of measured quantities. Plots should identify units, pressure convention, time or averaging interval, and any derived conversions.

```text title="Explain a completed CFD result" wrap theme={null}
Read the existing case and results without rerunning them. Report the achieved time, solver completion, mass balance, and pressure drop between the agreed planes. Show the averaging method and pressure units. Flag incomplete convergence or missing evidence, and provide labeled plots using comparable ranges for both revisions.
```

For thermal or coupled studies, confirm the required energy model and field transfer explicitly. A flow solution alone does not establish solid temperatures or structural response.

Continue with [Meshing](/cae/meshing), [Results and comparison](/cae/results), or [Troubleshooting](/cae/troubleshooting).


# Prepare geometry for simulation
Source: https://docs.adam.new/cae/geometry-preparation

Create an analysis copy with deliberate simplifications and traceable physical boundaries.

Geometry preparation should preserve the features that determine the response you care about. A small fillet may matter for local stress, while a logo may add mesh cost without affecting a global stiffness estimate.

## Define what must survive

Identify the source revision, length units, analysis type, material regions, and quantities of interest. Name contact surfaces, load areas, supports, inlets, outlets, or thermal interfaces that must remain identifiable.

Work on an analysis copy. Record any suppressed feature, repaired gap, merged body, or idealization so the study can be traced back to the design.

```text title="Prepare a housing for a stiffness study" wrap theme={null}
Inspect this housing for a structural stiffness study. Preserve the mounting pads, load introduction surfaces, wall thicknesses, and rib junctions. Identify cosmetic features that could be removed and geometry defects that could prevent meshing. Propose the simplifications before changing an analysis copy. Record the source revision and each change.
```

## Choose the physical domain

| Study | Geometry decision |
| - | - |
| Solid structural | Preserve the load path and relevant contact regions |
| Shell or beam idealization | Define thickness, section properties, offsets, and orientation |
| Internal flow | Extract the enclosed fluid region and identify openings |
| External flow | Create the surrounding fluid domain and justify its extent |
| Conjugate heat transfer | Preserve both fluid and solid regions and their interfaces |

## Check the prepared geometry

```text title="Verify the analysis copy" wrap theme={null}
Compare the prepared geometry with the source. Confirm units, envelope, body count, and the named regions used for supports and loads. Report removed features and any changes to volume or boundary area that could affect the study. Flag gaps, overlaps, or ambiguous contacts before meshing.
```

For CFD, verify that the region to be meshed is fluid space. For structural assemblies, verify how loads transfer between bodies; simply touching surfaces does not establish the intended contact behavior.

## Deliver the preparation record

Keep the source model, prepared geometry, simplification list, and named-region map. If the geometry changes later, recheck the boundary map before reusing it.

Continue with [Study setup](/cae/study-setup) and [Meshing](/cae/meshing). Use [Native CAE setup](/integrations/native-cae) when preparation must happen in a connected application.


# Create and check a simulation mesh
Source: https://docs.adam.new/cae/meshing

Resolve the important physics while preserving material regions and boundary assignments.

Ask Adam to mesh the analysis geometry for a named solver and study. A surface mesh that looks smooth may still have poor elements, missing regions, or incorrect boundaries for the solver.

## Specify the mesh requirements

Provide the source revision, units, solver, physics, and quantity of interest. Name thin regions, fillets, interfaces, or boundary layers that need attention. If you have an existing mesh, provide it and its quality report before requesting a rebuild.

```text title="Mesh a structural analysis copy" wrap theme={null}
Mesh the prepared housing for [solver] and the agreed structural study. Choose element type and order appropriate to the model. Refine the mounting pads and rib junctions locally. Preserve the named load, support, and material regions. Report node and element counts, solver-specific quality checks, failed regions, and boundary membership after export.
```

## Check the exported mesh

**1. Check scale and coverage**

Confirm the envelope, material regions, connectivity, and intended solid or fluid domain.

**2. Check element or cell quality**

Use the selected solver's metrics and supported element types. Locate failed regions so they can be repaired.

**3. Check boundary mappings**

Confirm required groups are nonempty and on the expected surfaces. Recheck after remeshing or topology changes.

**4. Read the solver input back**

Where a checker or parser is available, inspect the exported input rather than relying only on the mesher's display.

## Refine against the result

A larger mesh is useful only when it improves resolution of the relevant response. Compare displacement, pressure drop, stress at a defined location, or another chosen quantity across refinements while holding the physical inputs fixed.

```text title="Plan a mesh sensitivity check" wrap theme={null}
Create a refinement plan for this study within [time budget]. Keep geometry, material, loads, and output definitions fixed. Compare [quantity of interest] across the meshes, recording element or cell counts, quality, solve status, and the change in the measured result. Do not declare convergence from mesh count alone.
```

For CFD, include near-wall resolution and its compatibility with the wall treatment. For local structural stress, investigate whether a reported peak reflects a singularity before using it as a refinement target.

Retain the mesh, generation settings, boundary map, and quality summary. Continue with [Structural analysis](/cae/structural-analysis), [Fluid analysis](/cae/fluid-analysis), or [Troubleshooting](/cae/troubleshooting).


# Simulation workflows
Source: https://docs.adam.new/cae/overview

Define an engineering question, prepare a study, and evaluate the evidence from a solve.

Use Adam to prepare, troubleshoot, or interpret an engineering analysis. Begin with the question the study should answer: displacement under a load, a pressure drop, a temperature, or a comparison between design revisions.

## Choose where the study runs

| Path | Use it when | Before running |
| - | - | - |
| Adam task environment | You want an analysis from attached geometry or a generated model | Ask Adam to check the available solver and whether it supports the required physics |
| Connected native application | You need an existing native study or a specific commercial solver | Connect the licensed application on Windows and verify the intended model is accessible |
| Existing results | You want a study explained or compared | Supply the setup, solver output, logs, units, and revision; a rerun may be unnecessary |

Updated task environments include Gmsh, CalculiX, scikit-fem, and OpenFOAM. Availability and supported formulations must be checked in the actual task. See [native CAE setup](/integrations/native-cae) for commercial application connections, version constraints, and current qualification limits.

## Follow the study lifecycle

**1. Define the question**

Identify the geometry, physical conditions, quantity to measure, and acceptance limit if one exists.

**2. Prepare the model**

Preserve relevant geometry, assign material regions and boundaries, and choose a mesh suitable for the physics.

**3. Run and inspect**

Check the solver's completion state, diagnostics, and the achieved load or time. Inspect the requested response.

**4. Establish what the result supports**

Evaluate balance checks, refinement, assumptions, and comparisons before using the result for a design decision.

> [card] [Prepare geometry](/cae/geometry-preparation)
>
> Simplify deliberately and preserve the physical regions.

> [card] [Set up a study](/cae/study-setup)
>
> Translate requirements into materials, loads, and boundary conditions.

> [card] [Create a mesh](/cae/meshing)
>
> Check quality, domain coverage, and boundary assignments.

> [card] [Structural analysis](/cae/structural-analysis)
>
> Evaluate displacement, stress, and reactions.

> [card] [Fluid analysis](/cae/fluid-analysis)
>
> Evaluate flow, pressure drop, and supported thermal cases.

> [card] [Results and comparison](/cae/results)
>
> Read fields, compare revisions, and preserve reproducible evidence.

## Start with a study brief

```text title="Plan an analysis before running it" wrap theme={null}
I need to determine [engineering quantity] for [design and revision] under [operating conditions]. Review the attached geometry and requirements. Identify the appropriate physics, required material and boundary data, and an available solver. List missing inputs and propose a setup and verification plan within [compute budget]. Label any illustrative assumptions.
```

A completed solve establishes that a numerical job finished. An engineering conclusion also depends on the physical model, numerical checks, and the requirement being evaluated. If a run fails or gives an implausible answer, start with [simulation troubleshooting](/cae/troubleshooting).


# Interpret and compare simulation results
Source: https://docs.adam.new/cae/results

Connect plots and numbers to their source study, numerical checks, and engineering requirements.

When results already exist, ask Adam to inspect them before rebuilding or rerunning the study. Include the setup and logs alongside the result files so the numbers can be interpreted in context.

## Read a result with its provenance

Provide the source revision, solver and version, material and boundary data, mesh, achieved step or time, and output definitions. A plot without its units, component, or deformation scale can be misleading.

```text title="Review a structural result package" wrap theme={null}
Review the attached study and results. Identify the geometry revision, load case, solver completion, and achieved step. Report displacement at [location] and stress in [region], including units, component, and averaging convention. Inspect reactions and mesh sensitivity where the files support those checks. Separate observations from assumptions and list evidence needed before comparing with our requirement.
```

## Separate three conclusions

| Question | Evidence |
| - | - |
| Did the run finish? | Solver termination, exit status, achieved load or time, and diagnostics |
| Is the numerical result credible for this question? | Balance checks, finite values, refinement, and reference comparisons where appropriate |
| Does the design meet the requirement? | The relevant quantity compared with a supplied acceptance limit under justified assumptions |

A missing check should remain visible. Incomplete or unconverged results can help diagnose a problem but should not be presented as an accepted design result.

## Compare like with like

Use the same physical inputs, measurement locations, field components, and averaging conventions. Explain any change in the model or numerical method. Keep color ranges consistent when comparing contour plots.

```text title="Make a revision comparison table" wrap theme={null}
Compare these two result packages at the same operating conditions. Create a table with geometry revision, mesh size, solve status, measured [quantity], balance or equilibrium checks, and refinement evidence. Identify differences in inputs that prevent a fair comparison. Recommend further work only where the evidence supports it.
```

## Open and retain the deliverables

Adam opens supported `.sim.json` exports in its simulation viewer. Ask Adam to generate that export from the solved data when conversion is available, then open it from the task's files. A native solver database does not automatically become a viewer file. Keep the raw solver outputs and native study as well.

| Control | Use it to |
| - | - |
| Result field buttons | Select an exported field and read its units from the legend |
| **Mesh** | Show the displayed surface mesh edges |
| **Deformed shape** | Compare an exported displacement field with the original outline; check the scale multiplier |
| **Design** and **Compare** | Switch between cases and compare exported summary metrics when the file has multiple cases |
| **Same scale for all designs** | Keep a shared color range for comparable fields across designs |
| **Setup** | Read exported conditions, notes, and **Result provenance** |

The deformation control changes the display only; reported values remain unscaled. Controls depend on what the file contains. Setup text and comparison metrics describe the export; opening it does not independently verify the underlying solve.

For each plot, identify the field, units, region, step or time, and display scale. The simulation viewer displays an exported surface. For an interior slice, a time history, or a numerical probe, ask Adam to produce a separate plot or table from the source result data.

If the file shows **This simulation result could not be opened**, ask Adam to check and regenerate the viewer export while preserving the solver files. Renaming an arbitrary JSON file to `.sim.json` does not convert it.

Use [Troubleshooting](/cae/troubleshooting) for suspect results, or [Repeat engineering work](/guides/repeatable-work) to preserve an accepted study brief.


# Run a structural analysis
Source: https://docs.adam.new/cae/structural-analysis

Evaluate displacement, stress, and reactions with a documented model and verification checks.

Use Adam to set up a structural study, inspect an existing one, or compare design revisions. Name the solver if you have a requirement; otherwise ask Adam to check an available formulation appropriate to the problem.

## Choose the right physical model

A small-displacement linear study can answer some stiffness questions. Contact separation, snap fits, large deformation, impact, or material yielding may require different physics. A modal shape shows a vibration mode with arbitrary normalization; its plotted amplitude is not an operating displacement prediction.

Provide geometry and units, sourced material properties, physical attachment, loads, and the quantity you need. Distinguish an applied force from a prescribed displacement: the latter can be used to calculate the reaction needed to impose that motion.

## Start with a controlled example

```text title="Set up a simple stiffness calculation" wrap theme={null}
For an illustrative study, model a rectangular cantilever 120 mm long, 20 mm wide, and 4 mm thick. Use an ideal linear elastic material with E = 70 GPa and Poisson ratio 0.33. Fix the end at x = 0 and distribute a total 10 N load downward over the opposite end face, bending through the 4 mm thickness. Check small-deflection assumptions. Report tip displacement and support reaction, compare displacement with a beam estimate, and examine mesh sensitivity. Label the idealized fixture and material assumptions.
```

This is a numerical learning example, not a qualification of a real bracket or joint.

### Compare with the beam estimate

For the idealized end load above, the elementary bending estimate is `deflection = F L³ / (3 E I)`, with `I = width × thickness³ / 12`. In consistent N and mm units, `E = 70,000 N/mm²` and `I = 106.67 mm⁴`.

| Quantity | Reference value |
| - | - |
| Tip deflection magnitude | Approximately 0.771 mm |
| Vertical support reaction magnitude | 10 N |
| Support bending moment magnitude | 1,200 N·mm |

These are beam-theory reference values. A three-dimensional finite-element model can differ because of its formulation and end constraints. Ask Adam to explain the difference and mesh sensitivity. A factor-of-1,000 discrepancy is a reason to check units before changing the physics.

## Inspect setup and results

**1. Verify the physical inputs**

Read back material assignments, units, load direction and total, support locations, and contact assumptions.

**2. Run and preserve evidence**

Keep the input deck or native study, mesh, solver version, logs, and achieved load or time step.

**3. Check numerical behavior**

Review termination, finite results, equilibrium where available, and refinement of the requested response.

**4. Interpret the engineering result**

Compare against the supplied requirement and explain the effect of assumptions, singularities, or missing checks.

## Compare a design change

```text title="Compare two revisions at the same conditions" wrap theme={null}
Compare revisions A and B under the same documented load case. Rebuild geometry selections and remesh each revision. Report mass, displacement at [location], and stress using the same component and averaging convention. Keep material and support assumptions fixed. Include solver completion, reaction balance where available, and mesh sensitivity before recommending a revision.
```

A stress peak at an idealized constraint may not be a meaningful failure criterion. A factor of safety needs the appropriate material limit and failure mode; displacement alone does not establish strength.

For native studies, see [Native CAE setup](/integrations/native-cae). For deliverables, see [Results and comparison](/cae/results).


# Set up an engineering study
Source: https://docs.adam.new/cae/study-setup

Translate the physical test into documented materials, contacts, loads, and boundary conditions.

A study starts with a physical model. Give Adam enough information to distinguish what is known from what needs to be assumed, then request a setup summary before a costly solve.

## Bring the analysis brief

| Input | What to specify |
| - | - |
| Geometry | File or native document, revision, configuration, and units |
| Physics | Structural, fluid, thermal, steady, transient, linear, or nonlinear behavior as appropriate |
| Materials | Property values, units, conditions, and sources |
| Boundaries | Physical supports, contacts, loads, flow conditions, or heat transfer |
| Outputs | Exact quantity, location, component, and units |
| Acceptance | The supplied limit or comparison that determines a useful result |
| Budget | Available run time and how much refinement or iteration to attempt |

A material name alone may not establish temperature-dependent properties or a constitutive model. A picture of a fixture may not show its actual compliance. Identify these gaps before treating the setup as complete.

## Translate a test protocol

```text title="Turn a test brief into a setup plan" wrap theme={null}
Use the attached test protocol to prepare a study for [model], revision [revision], in [solver]. Extract the material properties, load cases, fixture conditions, and acceptance limits with their document locations. Map each load and support to the model and explain the idealization. Report unresolved inputs. Show the setup summary and estimated run scope before solving.
```

## Inspect the applied setup

For each region, request its name and measured location or extent. Verify load directions and total magnitudes, coordinate systems, contact behavior, and the consistency of units.

```text title="Check the applied boundary conditions" wrap theme={null}
Inspect the prepared study without solving. Show the bodies and material assignments, support and load regions, coordinate systems, and total applied force and moment where available. Compare them with the brief. List missing assignments, conflicting constraints, and any setting that could not be read back.
```

## Keep setup and execution distinct

Request the native study or input files with the setup summary. If the solver or required license is unavailable, Adam can still prepare inputs or review the model, but the deliverable should say that no solve occurred.

Use [Structural analysis](/cae/structural-analysis) or [Fluid analysis](/cae/fluid-analysis) for physics-specific checks, then [Results and comparison](/cae/results) to evaluate the output.


# Troubleshoot a simulation
Source: https://docs.adam.new/cae/troubleshooting

Locate the failing stage, preserve diagnostics, and test a focused correction.

Bring the exact error, solver log, study setup, and the last completed stage. Ask Adam to inspect the failure before changing the physics or rerunning an expensive job.

## Identify the failing stage

| Symptom | First checks |
| - | - |
| Application cannot connect | Connector, installed version, native session, and license |
| Mesh fails | Geometry defects, thin or sliver regions, sizing, and element suitability |
| Rigid-body motion or singular system | Supports, disconnected bodies, contact, and missing material assignments |
| Nonlinear solve does not converge | Contact changes, load increments, deformation, material behavior, and diagnostics |
| CFD diverges or has poor balance | Boundary conditions, mesh quality, physical model, initialization, and time step |
| Result is implausible | Units, load magnitude, region selection, material data, and output convention |
| Result appears unchanged after an edit | Source revision, remeshing, boundary mapping, and result freshness |

These are starting points for diagnosis. The log and model determine which explanation is relevant.

## Request a focused diagnosis

```text title="Investigate a failed solve" wrap theme={null}
Inspect this failed run without overwriting it. Identify the first meaningful error, the last completed step, and the affected region or entity if available. Rank likely causes using the setup and log evidence. Propose the smallest diagnostic change and explain what result would support or rule out the hypothesis.
```

Preserve the original files and logs. Changing several settings at once can make it difficult to tell which correction mattered.

## Retry deliberately

```text title="Test one proposed correction" wrap theme={null}
Apply the agreed correction in a new run directory, preserving the original case. Keep the other physical inputs fixed. Record the change, run within [budget], and compare termination, diagnostics, and [quantity of interest] with the previous attempt. If it fails again, retain the new logs and report what we learned.
```

Do not loosen quality or convergence criteria solely to obtain a success message. Explain what a changed criterion means for the result.

## Recover from interruptions

A lost connection or timeout does not establish that the native operation stopped. Ask Adam to inspect the application's current state and retained outputs before repeating an edit or solve. Native cancellation support varies; verify the solver actually stopped before starting another job.

For setup failures, see [Native CAE connections](/integrations/native-cae). For interpreting a completed run, see [Results and comparison](/cae/results). If you need support, include the task URL, application and version, time, and non-secret diagnostics.


# Scheduled tasks
Source: https://docs.adam.new/guides/automations

Run a task once in the future or repeat it on a schedule.

Scheduled tasks let Adam run saved instructions once in the future or on a repeating schedule.

## Create a schedule

**1. Open Scheduled**

Select **Scheduled** in the sidebar, then select **New scheduled task**.

**2. Describe the work**

Enter the instructions Adam should follow each time. You can also give the task a name.

**3. Choose when it runs**

Select a one-time date, hourly, daily, weekly, monthly, or custom schedule. Check the time zone shown before saving.

**4. Create and review**

Save the task. Open it later to see previous runs, change its instructions, or adjust the schedule.

## Manage a scheduled task

From **Scheduled**, you can search your scheduled tasks and use the action menu to:

* edit the name, instructions, or schedule;
* pause or resume future runs;
* review previous runs; or
* delete the automation.

Pausing keeps the task but stops future runs until you resume it.

For work in a desktop application, keep the schedule owner's paired workstation, connector, application, and required license available at run time. A schedule does not turn on an offline computer. Test the instructions once on a representative input before scheduling a batch or an edit.

## Event-triggered work

Adam can also create tasks that run after supported events in a connected product. Tell Adam what event should start the task and what it should do.

You can edit the task's name and instructions from **Scheduled**. To change the event that starts it, ask Adam to update or recreate the task.

> [!WARNING]
>
> Scheduled tasks can run while you are away. Be clear about what Adam may change. For sensitive work, ask it to report what it finds without making changes.

## Write reliable instructions

Include:

* what Adam should review;
* the time window to inspect;
* the expected output and destination;
* what counts as an exception; and
* whether Adam may make changes or should only report what it finds.

```text title="Example weekly research task" wrap theme={null}
Every Monday at 9:00 AM, search for engineering news about injection molding materials published during the previous seven days. Summarize the five most relevant updates, include a link to each source, and explain why each update matters to a product design team.
```


# Core concepts
Source: https://docs.adam.new/guides/core-concepts

Understand how Adam organizes tasks, files, teams, integrations, schedules, and memory.

## Tasks

A task is a conversation with Adam and everything produced during that conversation, including attached and generated files.

Keep related work in one task so Adam can use the earlier conversation and files. Start a new task for unrelated work or when you want to share it with different people.

## Progress, questions, and approvals

After you send a message, Adam shows its progress in the task. It may ask a question or wait for your approval before continuing.

Task status is summarized in the task list:

* **Running** means Adam is still working.
* **Needs input** means a question or approval is waiting for someone who can respond.
* **Completed** means Adam has finished the current request.
* **Scheduled** means the task is set to run later or repeat.

## Models

**Lite**, **Pro**, and **Ultra** are model families for different levels of work. Each family can include several models. Choose a family through the preset slider to use its default model, or open **Advanced** → **Model** to choose a particular model within it.

All models in a family share its plan requirements and usage limits. The models can still differ in how much allowance a request uses, and some support Fast mode.

If you connect Codex, its available models appear in a separate **Codex** section. They use your Codex plan limits instead of your monthly Adam usage.

Learn more about [model usage costs and connecting Codex](/admin/usage-costs).

## Files and outputs

Files include anything you upload and anything Adam creates. They can include CAD files, drawings, documents, images, spreadsheets, presentations, code, and data.

The right-hand file panel keeps task outputs close to the conversation. The global **Files** page searches across tasks and lets you preview or export files.

## Teams

Every account starts with a personal team. Shared teams add seats and roles, and share plan usage across members.

Team roles are **Owner**, **Admin**, and **Member**. A task's sharing permissions are separate: a person invited to one task can have **Can edit** or **Can view** access without changing their team role.

## Integrations

Integrations let Adam work with supported products and accounts.

* Connect Onshape or Arena to work with documents and records in those accounts.
* Install the Fusion add-in to work with a design open in Fusion.
* Use the Desktop Connector with supported applications such as SolidWorks, Revit, Blender, SketchUp, and Unreal Engine.

> [!NOTE]
>
> Fusion and other desktop applications need to be open while Adam works with them.

## Scheduled work

A scheduled task stores instructions and runs them once or on a recurring schedule. Open **Scheduled** to see upcoming runs and previous results.

## Memory

Memory lets Adam remember useful information across tasks. Open **Settings** → **Memory** to review or remove what Adam remembers.

Your memories are private to you, even in a shared workspace. Removing a memory deletes it permanently. In a shared workspace, owners and admins can turn memory off for everyone under **Admin** → **Team Scope** → **Memory**; turning it off permanently deletes every member's memories in that workspace.


# Find and export files
Source: https://docs.adam.new/guides/files

Search, preview, filter, download, and export files created or uploaded across Adam tasks.

The **Files** page brings together files you uploaded and files Adam created.

## Open the Files page

Select **Files** in the sidebar. Files can be shown as a grid or list and grouped by task or chronologically.

You can find CAD files, drawings, documents, images, PDFs, presentations, spreadsheets, code, data, and other supported formats.

## Search and filter

Use the search field to match file names and related task titles. Refine the result by:

* file type;
* **By Adam** or **My uploads**;
* the product or app where the file came from; and
* task grouping or chronological grouping.

Select a task title beside a file to return to the conversation that produced it.

## Preview a file

Select a file to preview it. If that format cannot be previewed, download the original and open it in the appropriate application.

Simulation results exported as `.sim.json` open in the simulation viewer. See [Results and comparison](/cae/results#open-and-retain-the-deliverables) for field, mesh, deformation, setup, and comparison controls. Keep the original solver files alongside the viewer export.

> [!NOTE]
>
> Open editable CAD files in their CAD application before approving a design change. The preview may not show feature history or other design details.

## Download or export

Use the menu on a file to download the original or choose an available export format.

## Keep outputs traceable

Ask Adam to use descriptive filenames when a task will create several outputs. Keep the review discussion in the same task so teammates can see why each file was created.

> [!TIP]
>
> When Adam changes a design, ask for a short summary of what changed and what you should still review.


# Connect tools and accounts
Source: https://docs.adam.new/guides/integrations

Connect CAD, simulation, electronics, PLM, and the tools around your engineering work.

Open **Integrations** in the sidebar to find a product or manage an existing connection. Use **Connected** to see the connections available to you in the current workspace. A connection can belong to your account or be shared with the team; connecting an account does not automatically give every teammate access.

## Choose a connection method

| Connection | Setup | While working |
| - | - | - |
| [Onshape](/integrations/onshape) | Authorize your Onshape account; optionally add the in-product panel | Keep Onshape open when using the panel |
| [Autodesk Fusion](/integrations/fusion) | Install Adam Connector and the Fusion add-in | Keep Fusion and the intended design open |
| [SOLIDWORKS](/integrations/solidworks) | Pair a Windows workstation; the bridge is bundled | Keep SOLIDWORKS and the intended document open; Simulation requires its own add-in and license |
| [Siemens NX](/integrations/nx) | Pair the NX Windows workstation | Use the same Windows account as NX; restart NX after bridge installation if needed |
| [Autodesk Inventor](/integrations/inventor) | Pair a Windows workstation; the bridge is bundled | Keep Inventor and the intended document open |
| [CATIA V5](/integrations/catia) | Pair a Windows workstation; the V5 bridge is bundled | Keep CATIA V5 and the intended part or product open |
| [CATIA V6 / 3DEXPERIENCE](/integrations/catia-v6) | Pair a Windows workstation; preview connection | Keep CATIA signed in with the intended design open |
| [Solid Edge](/integrations/solidedge) | Pair a Windows workstation; preview connection | Keep Solid Edge and the intended document open |
| [Rhino](/integrations/rhino) | Pair the computer and install the bundled Rhino plug-in | Keep Rhino 8 open on macOS or Windows |
| [Native CAE](/integrations/native-cae) | Pair a Windows workstation with a licensed simulation application | Verify the native session and model before running |
| [KiCad](/integrations/kicad) | Pair the Desktop Connector and enable the KiCad API | Follow the PCB and schematic-specific instructions |
| [Arena PLM](/integrations/arena) | Connect your Arena account | Use the account with access to the intended records |
| Other cloud products | Follow the sign-in steps in the integration card | Keep the authorization current |

Use [Desktop Connector setup](/integrations/desktop-connector) for workstation pairing. See [Supported software](/supported-software) for the full application catalog, versions, and preview notes.

## Connect an integration

**1. Choose your team**

Select the Adam team that should use the connection.

**2. Open the integration**

Go to **Integrations**, search for the product, and open its connection card.

**3. Complete setup**

Sign in, install the connector or add-in, pair a computer, or enter a key as requested.

**4. Check the intended target**

Confirm the account or application is connected, then ask Adam to inspect the intended document or record.

## Use the connection in a task

Name the application, computer or account if relevant, document, and requested outcome. For a review, state that the source should remain unchanged.

```text title="Inspect a connected design" wrap theme={null}
Inspect [document or record] in [application]. Confirm its identity and revision, summarize the information you can read, and identify what is needed to [goal]. Keep this initial inspection read-only.
```

Once the target is clear, continue with a [CAD workflow](/cad/overview) or [simulation workflow](/cae/overview).

## Manage access

Workspace administrators can restrict integrations for the workspace or individual members. If an integration is missing or blocked, check with an administrator before reconnecting it.

For integrations requiring an API key, use a dedicated key with the permissions the task needs. Adam will not display the full key again after saving it. Use the integration setup form for credentials.

Disconnect an account from its integration page or **Connected** when the team no longer needs it. Unpair workstations you no longer control. If a connection expires or cannot access a particular document, follow [Troubleshooting](/resources/troubleshooting).


# Organize work with projects
Source: https://docs.adam.new/guides/projects

Keep related Adam tasks, shared files, instructions, and memories together in a project.

A project gives related tasks a shared starting point. Use one for a product, client, design, or other stream of work that needs the same instructions and reference files.

Each project can include:

* a **brief** that tells Adam what every task in the project should know;
* **files** that are available to tasks in the project;
* related **tasks**; and
* a project memory setting that controls where memories learned during those tasks can be used.

> [!NOTE]
>
> Projects are available on paid plans.

## Create a project

**1. Open Projects**

Select **Projects** in the sidebar, then select **New Project**.

**2. Name the project**

Use a name that distinguishes this work from your other projects.

**3. Add shared context**

Write a brief and attach any files that every task in the project should be able to use. You can add or change both later.

**4. Choose the memory scope**

Select **Project only** to keep memories inside the project, or **All tasks** to let Adam use them elsewhere in your workspace.

**5. Create the project**

Select **Create project**. Adam opens the new project when it is ready.

## Start or move tasks

There are three ways to add work to a project:

* Open the project and select **New task**.
* Choose a project from the project picker beside the model picker before starting a task.
* Open a task you own, select its action menu, choose **Move**, and select a project.

The project picker appears only when you have at least one project. A task started inside a project receives the project brief and shared files automatically.

To take a task out of a project, open the task menu, choose **Move**, then select **Remove**. Only the task owner can move it between projects.

## Maintain the brief and files

Open a project to see its **Tasks** and **Files** tabs.

The brief is editable on the project page. Select the text, make your changes, then click or tab away to save it. Keep the brief focused on information that should apply to every task, such as:

* the outcome and current stage of the work;
* requirements and constraints;
* naming or documentation conventions; and
* decisions that future tasks should preserve.

Use the **Files** tab to upload more reference files. Project tasks can use these files without you attaching them to every conversation.

> [!TIP]
>
> Put project-wide context in the brief. Keep instructions that only apply to one piece of work in that task's first message.

## Choose how project memory works

Project memory controls where Adam may reuse memories learned while working in the project.

> [tab] Project only
>
> Only tasks in this project can use its memories. Use this for work that should stay isolated from unrelated tasks.

> [tab] All tasks
>
> Tasks inside and outside the project can use its memories. Use this when the knowledge is useful across your workspace.

The setting does not change the project's brief or shared files. To change it later, open the project action menu, select **Settings**, then choose a memory option in **Project Settings**.

## Control access

On a shared team, the project owner can set the project to **Private** or **Team**.

* **Private** limits access to the owner and people invited to the project.
* **Team** makes the project available to the team.

Use **Share** to invite someone directly as **Can edit** or **Can view**. Editors can work in project tasks; viewers have read-only access. Projects do not support anonymous public links.

Only the project owner can manage invitations. Workspace collaboration policy applies to projects as well as tasks. It can block invitations or limit them to workspace members; tightening the policy can revoke existing access that it no longer allows.

People invited directly to a project can leave it from the project action menu. The owner can change or remove an invited person's access from **Share**.

## Find and manage projects

The **Projects** page lets you search projects and switch between grid and list views. Use a project's action menu to pin or rename it. Project owners can also change settings or delete the project.

Deleting a project removes the grouping and its shared access. Its tasks and files are kept, but they are no longer grouped through that project.

For task-specific collaboration and public links, see [Work with tasks](/guides/workflows). To search files across your workspace, see [Find and export files](/guides/files).


# Repeat engineering work
Source: https://docs.adam.new/guides/repeatable-work

Reuse a clear brief, reference files, and acceptance checks across parts and revisions.

When the same job comes back with a new part or revision, keep the procedure and change the inputs. A useful reusable brief records enough detail for someone else to review the result.

## Build the brief on one representative part

Start a task with the actual source file, template, and requirements. Refine the result until the modeling steps, drawing layout, review rules, or analysis setup are appropriate for that part family.

Then ask Adam to extract the procedure:

```text title="Turn a completed task into a reusable brief" wrap theme={null}
Write a reusable brief for the work we just completed. Separate the inputs that change for each part from the fixed rules. Include required files, application and template, units, steps, output names, verification checks, and conditions that should stop the task. Record unresolved assumptions. Save it as a document I can review and reuse.
```

Review the brief before reusing it. A successful run on one part does not establish that the process handles every geometry, configuration, or drawing template.

## Keep shared context in a project

Add the brief and reference files to a [project](/guides/projects). Name the current template and requirements clearly so a future task does not choose an obsolete version. Keep an example of an accepted output alongside the rules that made it acceptable.

Projects require a paid plan. Without a project, save the brief and attach it with the reference files when starting the next task. The brief is a reusable document; it does not create a saved executable workflow or automatically run against new files.

| Fixed context | Inputs that change |
| - | - |
| Drawing template and annotation policy | Part, configuration, and revision |
| Supplier's manufacturing limits | Geometry and material |
| Analysis method and reporting convention | Load case and source model |
| Required checks and output formats | Destination folder and file names |

## Run against new inputs

```text title="Apply a reviewed brief to another part" wrap theme={null}
Use the drawing brief in this project for [new part], revision [revision], configuration [configuration]. Check that its required inputs are present and that the procedure applies to this part. Create the outputs in [destination]. Report the source revision, checks performed, exceptions, and files produced.
```

For [batches](/cad/batch-operations), try a representative file first and request a per-file report. For work that should run at a particular time, use [Scheduled tasks](/guides/automations); connected desktop applications still need to be available when the work runs.

## Keep the procedure current

Recheck the brief when the CAD application, solver, material, supplier rule, or template changes. Preserve the source and revision for each result so you can distinguish a repeated method from a repeated assumption.


# Work with tasks
Source: https://docs.adam.new/guides/workflows

Start, follow, organize, and share tasks in Adam.

A task keeps your conversation with Adam and its files together.

## Start a task

Select **New Task** in the sidebar and describe what you want to accomplish. Mention the relevant file or product and anything Adam should preserve or avoid changing.

You can give Adam more information in several ways:

* attach files with the composer button;
* drag files onto the task;
* paste text or an image;
* ask Adam to use a connected product; or
* start from inside Onshape or Fusion while viewing the design you want to work on.

## Follow a running task

Adam shows its progress in the conversation. It may pause to ask a question or request approval. Respond in the task to continue.

You can send another message while Adam is working. It will pick up the message when it is ready.

> [!TIP]
>
> For important changes, ask Adam to explain what it plans to do and wait for your approval before editing anything.

## Find and filter tasks

Open **Tasks** to search the workspace. Available filters include:

* **All**, **Mine**, and **Team** on shared teams;
* **Active**, **Needs input**, **Completed**, and **Scheduled**;
* where the task started, such as **Web**, **Onshape**, or **Fusion**; and
* the open CAD document when you are working inside a supported CAD panel.

You can rename, pin, or delete tasks from the task menu. Deleting a task is permanent, so review any files you still need first.

## Review files

Files open beside the conversation on larger screens. Use the file tabs to compare outputs without leaving the task.

Open [Files](/guides/files) from the sidebar to search across all tasks.

## Share a task

Task sharing is separate from team membership.

The task owner manages invitations and published links. Workspace policy can disable public links, collaboration, or invitations to people outside the workspace. If a sharing option is unavailable, ask your workspace administrator to check the policy.

> [tab] Invite people
>
> Open the task's share control, select **Share**, enter an email address, and choose **Can edit** or **Can view**.
>
> A person with **Can edit** can send messages in that task. A person with **Can view** has read-only access.
>
> Work in the task continues using the task owner's execution context, including their paired desktop workstation. An editor's message does not switch the task to that editor's computer.

> [tab] Publish a link
>
> Open the **Publish** tab and choose a plain public link or a password-protected link. Published links are read-only.
>
> Switch the task back to private to disable the link. If you change the password, visitors must enter the new one.

> [!WARNING]
>
> Review every message and attachment before publishing. Anyone with access to the link can read the full conversation and open its files. Messages are not redacted.

## Continue related work

Reply in the same task when the earlier conversation, design, or files still matter. Start a new task for unrelated work or when you want to share it with different people.

When work spans several tasks that should use the same brief and reference files, organize it in a [project](/guides/projects).

For repeatable engineering work, keep the inputs, procedure, and checks in a [reusable brief](/guides/repeatable-work). Use [Scheduled tasks](/guides/automations) when it should run at a particular time or recur automatically.


# Build, check, and document with Adam
Source: https://docs.adam.new/index

Practical guides for CAD modeling, engineering drawings, simulation, and the work around a design.

Adam helps you work on engineering designs through conversation. Connect your CAD application to edit native models, attach files for review, or ask for an analysis with the inputs and checks you need.

Start with the result you want. Each workflow explains what to provide, gives you a request to try, and shows what to inspect before using the output.

> [card] [Create or change a model](/cad/modeling)
>
> Describe the geometry, preserve important interfaces, and check the finished part.

> [card] [Make an engineering drawing](/cad/drawings)
>
> Turn a model into views, dimensions, and a PDF you can review.

> [card] [Review a design](/cad/manufacturing-review)
>
> Check a part against its manufacturing process and your supplier's requirements.

> [card] [Set up a simulation](/cae/overview)
>
> Define the physical problem, choose a solver, and inspect the numerical evidence.

## Get to a useful first result

**1. Bring the design**

Attach a drawing or CAD file, or connect an application from **Integrations**. Use the [software guide](/supported-software) to choose the setup path.

**2. Describe the outcome**

Name the part and revision, give units and requirements, and say what should stay fixed. The [quickstart](/quickstart) walks through a first drawing review.

**3. Inspect the result**

Open the model, drawing, report, or simulation output. Ask Adam to show the measurements and unresolved items that support its conclusion, then refine the work in the same task.

## Find your workflow

| Your next job | Start here |
| - | - |
| Modify a part or assembly | [CAD modeling](/cad/modeling) |
| Rebuild a part from a drawing | [Drawing to model](/cad/drawing-to-model) |
| Check dimensions and annotations | [Drawing review](/cad/drawing-review) |
| Evaluate an assembly gap or fit | [Tolerance analysis](/cad/tolerance-analysis) |
| Fix a failed feature or reference | [Repair a model](/cad/repair) |
| Prepare geometry and a mesh | [Geometry preparation](/cae/geometry-preparation) and [meshing](/cae/meshing) |
| Calculate stress or displacement | [Structural analysis](/cae/structural-analysis) |
| Calculate flow or pressure drop | [Fluid analysis](/cae/fluid-analysis) |
| Explain solver output | [Results and comparison](/cae/results) |
| Prepare a handoff | [Engineering documentation and release](/cad/documentation-and-release) |

## Connect your tools

Use Onshape through an account connection, Autodesk Fusion through its add-in, and supported local applications through the Desktop Connector. Native simulation connections require the corresponding application and license; see their availability and setup notes before starting.

> [card] [Software and requirements](/supported-software)
>
> CAD, CAE, electronics, and PLM connection paths in one place.

> [card] [Desktop Connector](/integrations/desktop-connector)
>
> Pair your workstation and confirm the intended application and document.

## Keep the work together

Use [tasks](/guides/workflows) for the conversation, [projects](/guides/projects) for shared context, and [files](/guides/files) for outputs. Save a repeatable brief with the inputs and checks your team needs using [Repeat engineering work](/guides/repeatable-work).

For account questions, see [setup](/setup), [teams](/admin/team), and [billing](/admin/billing). To use Adam from another application, start with [MCP](/mcp/overview) or the [API reference](/api-reference/introduction).


# Altium Designer
Source: https://docs.adam.new/integrations/altium

Connect Adam to native Altium Designer on Windows.

Connect Altium Designer to inspect and edit native PCB layouts, schematics, symbols, and footprints, capture design views, and run configured output jobs.

## Set up

1. Install Altium Designer on your Windows PC.
2. Install the Adam desktop connector and sign in to pair that computer.
3. Open one Altium Designer session under the same Windows account, then open the document you want to work on.
4. Select **Integrations → Altium Designer** in Adam and test the connection.

Nothing else needs installing: the connector runs scripts through Altium Designer itself. Altium Designer must be licensed and able to run scripts.

## Working on a design

Adam reads the focused document and checks its path before edits. Keep the intended document open. Review changes in Altium and save the native project deliberately. Full electrical and design-rule verification requires the relevant Altium checks and reports.

For manufacturing exports, open the appropriate `.OutJob`, inspect its available output containers, and ask Adam to run the ones you need.

## If a script does not finish

An operation can complete after a connection timeout. Ask Adam to check its operation status before making another edit. If Altium's script debugger is paused, stop the script, inspect any partial changes, and restart Altium before reconnecting. Never repeat an uncertain edit just because its response did not arrive.

This is an Adam integration, not an Altium product.


# Connect Arena PLM
Source: https://docs.adam.new/integrations/arena

Connect an Arena account so Adam can work with items, BOMs, suppliers, files, and changes.

Connect Arena so Adam can work with the items, bills of materials, suppliers, files, and changes that you can access.

## Connect Arena

**1. Open Arena in Integrations**

In Adam, select **Integrations**, search for **Arena**, and open its connection card.

**2. Enter your Arena credentials**

Sign in with the Arena email address and password for the account Adam should use.

**3. Verify the account**

Confirm Arena appears under **Connected**, then ask Adam to inspect a known item or change without editing it.

Adam does not save your Arena password.

## Work safely with PLM data

Adam has the same Arena access as the account you connect. Use an account with the right permissions for the work you want Adam to do.

For important changes, ask Adam to review the record before editing it:

```text title="Review an Arena change before editing" wrap theme={null}
Review change order [number]. Summarize the affected items, BOM changes, missing approvals, and missing attachments. Do not change anything in Arena. Recommend the next steps and wait for my approval.
```

> [!WARNING]
>
> Changes to items, bills of materials, and change orders can affect manufacturing work. Tell Adam exactly which records it may change and ask it to wait for approval when you are still exploring.

## Disconnect or reconnect Arena

Open **Integrations** → **Connected**, select Arena, and disconnect the account when it should no longer be used by the team.

If Arena stops responding:

* confirm the Arena account can sign in directly and is not locked;
* check whether the account's password, role, or organization access changed;
* disconnect and reconnect the account; and
* retry with a specific record that the account is known to access.


# Connect CATIA V5
Source: https://docs.adam.new/integrations/catia

Connect CATIA V5 on Windows to inspect parts and products and work through CATIA Automation.

Connect CATIA V5 to read the active document, edit parts and products, run CATIA Automation scripts, capture the viewer, and exchange CAD files. The Desktop Connector includes the CATIA V5 bridge.

## Before you begin

Use a Windows PC with CATIA V5 installed and licensed. Open the intended document and make sure its referenced parts are accessible. This connection supports **CATIA V5**. For the separate V6 preview, see [CATIA V6 / 3DEXPERIENCE](/integrations/catia-v6).

## Connect

**1. Pair the CATIA workstation**

In Adam, open **Integrations > CATIA V5** and follow [Desktop Connector setup](/integrations/desktop-connector#pair-a-workstation). Use the existing pairing if this workstation is already connected to your Adam account.

**2. Open the intended part or product**

Keep CATIA V5 and the connector running on the same Windows PC. No separate plug-in installation is required for the bundled bridge.

**3. Verify the active document**

Confirm the integration's connection status, then use the read-only request below to identify the document and target part.

```text title="Check the CATIA V5 document" wrap theme={null}
Inspect the active CATIA V5 document without changing it. Report whether it is a part or product, its name, and any unresolved references or existing update errors you can read. For a product, identify the part that would receive the requested edit before proceeding.
```

## Use the connection

Name the target part or product, the feature to change, and the geometry to preserve. Ask for an update and a check of the resulting dimensions. Follow [CAD modeling](/cad/modeling) for an edit or [documentation and release](/cad/documentation-and-release) for a reviewed handoff.

## If it does not connect

* **The workstation is online but CATIA is unavailable:** open CATIA V5 and its document on the paired Windows PC.
* **A product contains unresolved parts:** resolve the references in CATIA before requesting changes to dependent geometry.
* **The wrong part would be edited:** explicitly identify the product and target part, then repeat the inspection.
* **An edit was interrupted:** inspect the document before retrying because the operation may already have changed it.

For device and shared-task issues, see [Desktop Connector troubleshooting](/integrations/desktop-connector#if-an-application-is-offline).


# Connect CATIA V6 / 3DEXPERIENCE
Source: https://docs.adam.new/integrations/catia-v6

Connect CATIA V6 / 3DEXPERIENCE on Windows through Adam Connector.

Connect Adam to the CATIA V6 / 3DEXPERIENCE desktop app on your Windows PC. CATIA V5 has a [separate connection](/integrations/catia).

## Before you begin

Use a Windows PC with a licensed CATIA V6 / 3DEXPERIENCE desktop app (`3DEXPERIENCE.exe`). Open it, sign in, and open your design. The desktop app must be running; a browser or the 3DEXPERIENCE launcher alone is not enough. The older standalone `CATIA.exe` app is not supported.

Run CATIA and Adam Connector from the same Windows account. Open both normally or both with **Run as administrator**. If several CATIA sessions are open, ask Adam to list them and select the one you want to use.

## Connect

**1. Connect your computer**

In Adam, open **Integrations > CATIA V6 (3DEXPERIENCE)** and follow [Desktop Connector setup](/integrations/desktop-connector#pair-a-workstation). If this computer is already paired, use the existing connection.

**2. Open CATIA and your design**

Keep CATIA and Adam Connector running. No separate CATIA plug-in is required.

**3. Check the open design**

Once connected, ask Adam to inspect the design you want to work on without making changes.

```text title="Check the CATIA V6 session" wrap theme={null}
Inspect my open CATIA V6 design without changing it. Tell me which design is open and summarize the parts, features, or product structure you can read. Note anything you cannot inspect.
```

## Work with your design

Tell Adam which design to change and what you want, including dimensions or other requirements. Adam checks which design is active before making an edit.

If an edit fails, changes may remain in the model. Ask Adam to inspect it before retrying. Say explicitly when you want to save to 3DEXPERIENCE, replace a design, or export a file.

Adam can look up the Automation APIs installed with your CATIA version before
writing a script. For API lookup, the matching `DSYAutomation.chm` reference file
must be in the same folder as `3DEXPERIENCE.exe`.

## If it does not connect

* **The computer is online but CATIA is unavailable:** open the CATIA desktop app and sign in.
* **Several sessions are open:** ask Adam to list them and select the one you want to use.
* **The open design changed:** ask Adam to inspect it and confirm which design to change before retrying.
* **A request timed out or is still running:** ask Adam to check its status and result before making more changes or switching CATIA sessions. Do not submit the same edit again while it is running.

For help pairing your computer or fixing connection issues, see [Desktop Connector troubleshooting](/integrations/desktop-connector#if-an-application-is-offline).


# Connect desktop engineering applications
Source: https://docs.adam.new/integrations/desktop-connector

Pair a workstation and connect supported CAD, CAE, electronics, and 3D applications.

The Adam Desktop Connector links Adam to applications running on your computer. Install it on the workstation where you use the application, then pair that computer with Adam.

See [Supported software](/supported-software) for connection paths and requirements. Autodesk Fusion has a dedicated [installation guide](/integrations/fusion); commercial simulation applications have [native CAE setup instructions](/integrations/native-cae).

## Pair a workstation

Your Adam account has one paired workstation at a time. Pairing another computer disconnects the previous one. The same paired workstation serves its supported applications, so you do not pair separately for SOLIDWORKS, NX, and CAE.

**1. Open the integration**

In Adam, select **Integrations**, choose your application, and open its setup flow. Check that you are in the intended Adam team.

**2. Install the Desktop Connector**

Use the download in the setup flow on the same computer as the application.

**3. Pair the computer**

Generate a pairing code in Adam and enter it in the Desktop Connector. Codes expire, so generate a new one if the previous code is no longer accepted.

**4. Complete application setup**

Follow the application-specific instructions below and in its integration card. Keep the connector and application running.

**5. Verify access**

Return to the integration and confirm the application is connected. Start with a read-only request that identifies the intended document.

If you are using the Adam desktop app on that workstation, its built-in connector can pair directly from the setup flow without a separate download or manually entering a code.

## Application setup

> [tab] SOLIDWORKS
>
> Use a Windows PC with SOLIDWORKS installed and licensed. The connector includes the SOLIDWORKS bridge; open SOLIDWORKS and the intended part, assembly, or drawing.
>
> SOLIDWORKS Simulation uses this same connection. Adam can load the installed Simulation add-in when a Simulation task starts; SOLIDWORKS checks the required license. The CAD connection alone does not establish Simulation availability.
>
> Follow the [SOLIDWORKS guide](/integrations/solidworks) to verify the active model and troubleshoot the connection.

> [tab] NX
>
> Install the connector under the same Windows account as Siemens NX. Open NX normally. If NX was already open during connector installation, save your work and restart NX once so its registered Adam bridge can load.
>
> Wait until NX finishes starting, then verify the intended work part before editing. Use the [Siemens NX guide](/integrations/nx) for the connection check and recovery steps.

> [tab] Inventor and CATIA
>
> Use a Windows PC with the corresponding application installed and licensed. The connector includes the Inventor and CATIA V5 bridges; no separate plug-in installation is required for these bridges.
>
> Open Inventor or CATIA V5 and the intended document, then keep both the application and connector running. Continue with the [Inventor guide](/integrations/inventor) or [CATIA V5 guide](/integrations/catia) to verify the document and its references.

> [tab] Solid Edge
>
> Solid Edge is a preview connection for Windows. Open the application on the paired computer.
>
> Native workflows are awaiting qualification on a licensed Solid Edge installation. Follow the [Solid Edge guide](/integrations/solidedge) to check the requested operation on a representative copy before adopting it for your workflow.

> [tab] Other applications
>
> **KiCad:** install KiCad 10 and follow the [API and schematic reload steps](/integrations/kicad).
>
> **Rhino:** use Rhino 8 on macOS or Windows. Follow the [Rhino guide](/integrations/rhino) to install its bundled plug-in from Adam Connector and verify the document.
>
> **Revit:** use Revit 2027 on Windows with Autodesk's Public MCP Server Tech Preview, following the setup shown in Adam.
>
> **SketchUp:** use SketchUp 2019 or later. The connector installs its SketchUp extension for you; if SketchUp was open when that happened, restart it once. If you installed the third-party SketchUp MCP extension for an earlier setup, you can remove it.
>
> **Blender:** use Blender 3.2 or later. The connector installs its Blender add-on for you; if Blender was open when that happened, restart it once. If you installed the third-party Blender MCP add-on for an earlier setup, you can remove it.
>
> **Unreal Engine:** enable the MCP server under **Editor Preferences > Model Context Protocol**, or use `ModelContextProtocol.StartServer` in the editor console. Keep the editor open.

## Check the document

```text title="Confirm a desktop connection" wrap theme={null}
Inspect [application] on [computer] without making changes. Report the active document, application version, units where available, and any existing errors. If multiple sessions are open, identify the one you can access before proceeding.
```

Once the target is confirmed, try [modeling](/cad/modeling), [drawing creation](/cad/drawings), or [simulation](/cae/overview).

## Connect a custom MCP server

Use **Custom MCP** for your own trusted local server with a **Streamable HTTP** MCP endpoint. Enter the endpoint URL in the Desktop Connector, verify the server is running, and test it with a read-only request.

A command-line stdio server cannot be entered as a URL; expose a supported HTTP endpoint first. Connected tools can act with the permissions of the local server, so use a server you intend to give access to your work.

## If an application is offline

Check the paired computer, the running connector, and the target application's setup separately. A paired computer can be online while an application is closed or its plug-in is unavailable.

If you use Adam in a browser on a Mac while CAD runs on a Windows workstation, pair the Windows workstation. Installing the connector on the Mac does not give it access to Windows applications on another computer.

In a shared task, desktop work uses the task owner's paired workstation. It does not switch to a collaborator's computer when that collaborator sends a message. Confirm the owner and target before an edit.

For NX, save and restart after bridge installation if needed. For CAE, review [application readiness](/integrations/native-cae#understand-readiness). Re-pair if the device connection itself has expired or been removed.

Open the integration to manage or unpair devices you no longer use. If an interrupted task may already have changed a model, inspect it before retrying the operation.


# Install Adam for Autodesk Fusion
Source: https://docs.adam.new/integrations/fusion

Install Adam Connector to add Adam to Fusion, then work from the in-product panel or Adam web app.

Install Adam Connector to work with your Fusion designs. It includes the Adam add-in for Fusion and installs it for you. You can start a task from inside Fusion or use the Adam web app while Fusion is open.

## Install Adam Connector

**1. Download Adam Connector**

Open [fusion.adam.new/install](https://fusion.adam.new/install) on the macOS or Windows computer where Fusion is installed.

**2. Open Adam Connector**

Close Fusion while Adam Connector sets up the Fusion add-in, then open Fusion again.

**3. Open Adam in Fusion**

Open a design and select **Adam** from the Fusion toolbar. Sign in to Adam from the panel if prompted.

![Fusion toolbar with the Adam add-in button](https://mintcdn.com/adam-585915d9/SOvZH_gvRGaOooNN/images/product/fusion-toolbar-adam.png?fit=max\&auto=format\&n=SOvZH_gvRGaOooNN\&q=85\&s=61e24454c19bd621c8efe468d51bc881)

Select **Adam** in the Fusion toolbar to open the add-in.

**4. Start a task**

Ask Adam about the open design or selected geometry. The same task is also available in the Adam web app.

![Adam task showing a Fusion engine assembly and its generated work](https://mintcdn.com/adam-585915d9/SOvZH_gvRGaOooNN/images/product/fusion-webapp-tasks.jpg?fit=max\&auto=format\&n=SOvZH_gvRGaOooNN\&q=85\&s=00ba5dc89e7e8a233c9e44e1147308e8)

Fusion tasks also appear in Adam, where you can continue the conversation and review files.

## If the Adam button is missing

In Fusion, press **Shift+S** to open **Scripts and Add-Ins**. Find **AdamFusion** under **Add-Ins**, select it, and choose **Run**. If it is not listed, open Adam Connector, install the Fusion add-in, and restart Fusion.

## Work with a Fusion design

Keep Fusion open while Adam works with a design. If Adam cannot see Fusion, open the intended design and select **Adam** from the toolbar.

Adam can use the open design and your current selection. In your message, still describe the geometry, constraints, and changes that matter.

> [!TIP]
>
> For an important edit, ask Adam to explain the planned changes and wait for your approval before applying them.

## Try an engineering workflow

Use [CAD modeling](/cad/modeling) for a parameter change or new part, [Manufacturing review](/cad/manufacturing-review) for a process-specific review, or [Drawing to model](/cad/drawing-to-model) for a reconstruction. Name the design and component, describe any active selection, and request the native design alongside exchange files when you need editable history.

## Reinstall or update

Open Adam Connector to update or reinstall the Fusion add-in, then restart Fusion. If you do not have Adam Connector yet, download it from [fusion.adam.new/install](https://fusion.adam.new/install).

If the add-in runs but cannot reach Adam, check [Adam service status](https://status.adam.new), then sign out and back in from the panel before reinstalling.


# Connect Autodesk Inventor
Source: https://docs.adam.new/integrations/inventor

Connect Inventor on Windows to inspect and edit native parts and assemblies.

Connect Autodesk Inventor to read the active document, edit parametric parts and assemblies, run Inventor API scripts, capture the viewport, and exchange CAD files. The Inventor bridge is bundled with the Desktop Connector.

## Before you begin

Use a Windows PC with Inventor installed and licensed. Open the intended document and make sure its referenced files are available. No separate plug-in installation is required for the bundled Inventor bridge.

## Connect

**1. Pair the Inventor workstation**

In Adam, open **Integrations > Autodesk Inventor** and follow [Desktop Connector setup](/integrations/desktop-connector#pair-a-workstation). Reuse the existing pairing if this workstation is already connected to your account.

**2. Open the target document**

Keep Inventor and the connector running on the same Windows PC. Open the part or assembly you want Adam to inspect.

**3. Confirm the connection and document**

Check the integration's application status and run the read-only request below before making changes.

```text title="Check the Inventor document" wrap theme={null}
Inspect the active Inventor document without making changes. Report its name, document type, units, and any unresolved references or existing update errors you can read. For an assembly, identify the component I should target before editing a part.
```

## Use the connection

For a parametric edit, name the part or assembly component, the parameter or feature, and the required value. Ask Adam to update the document and verify the resulting dimensions. See [CAD modeling](/cad/modeling) for an example, or [batch operations](/cad/batch-operations) for a controlled export workflow.

## If it does not connect

* **The device is online but Inventor is unavailable:** open Inventor and its document on the paired Windows PC, then recheck the application's status.
* **An assembly has missing references:** resolve the referenced files in Inventor before asking Adam to change dependent geometry.
* **Adam has the wrong target:** name the document and component explicitly and repeat the inspection.
* **A task stopped during an edit:** inspect the current model before repeating the change.

For pairing and shared-task ownership, see [Desktop Connector troubleshooting](/integrations/desktop-connector#if-an-application-is-offline).


# Connect KiCad
Source: https://docs.adam.new/integrations/kicad

Connect KiCad 10 on your computer to Adam to design schematics and PCBs, run checks, and export manufacturing and mechanical files.

Adam works with KiCad on your computer through Adam Connector. Adam runs its work inside KiCad's own Python, so there is nothing else to install: no Node.js, pip packages, or separate MCP server.

## Connect

**1. Install KiCad 10**

Download KiCad 10 from [kicad.org](https://www.kicad.org/download/) and install it with its symbol, footprint, and 3D-model libraries. Adam supports KiCad 10 on macOS (Apple Silicon and Intel) and Windows (64-bit).

**2. Pair Adam Connector**

In Adam, open **Integrations → KiCad**, install Adam Connector if you don't have it, and pair your computer. If the computer is already paired, the existing connection works.

**3. Turn on the KiCad API**

In KiCad, open **Preferences → Preferences…** (**⌘,** on macOS), select **Plugins**, check **Enable KiCad API**, and select **OK**. This lets Adam see which project you have open and edit the board in the PCB editor while you watch.

**4. Open your project**

Ask Adam to work in KiCad. If KiCad is closed and its installation is known, Adam opens it for you and waits for the connection. If its location cannot be found, Adam asks you to open KiCad once so it can remember the installation. Open the project and the **PCB Editor** for the board you want to work on. Adam checks KiCad’s Python runtime before showing Connected. The first check may take a few seconds.

**5. Start a task**

Ask Adam: **"Look at my open KiCad project without editing anything. Which board and schematic are open, and does the board pass its design-rule check?"**

## How Adam edits your design

**Boards** open in the PCB editor are edited live: changes appear in KiCad right away, unsaved, so you can review them and undo with **Edit → Undo**. Save the board in KiCad when you're happy with it.

**Schematics** are edited on disk, because KiCad 10's schematic editor can't take changes from other programs. If a schematic is open in KiCad:

1. **Save it** before asking Adam to change it. Adam checks and asks if it's open.
2. When Adam is done, choose **File → Revert** in the schematic editor (or close and reopen it) to load Adam's changes.
3. **Don't save from the schematic editor before reverting.** Saving the old copy would overwrite Adam's changes.

Adam checks its work with KiCad's own electrical rules check (ERC) and design-rule check (DRC), and looks at rendered pictures of your schematic sheets and board, including 3D views.

## Get files out of KiCad

Ask Adam for Gerbers and drill files, a bill of materials, a placement file, PDFs, or a STEP model. Adam exports them with KiCad and brings them into your Adam workspace, where you can download or share them.

## Send a board to mechanical CAD

Ask Adam to export a STEP model of the board and bring it into your mechanical CAD tool, such as Fusion or SOLIDWORKS. Check dimensions, orientation, component bodies, and clearances in the mechanical CAD model.

A STEP file is a one-time geometry handoff. It doesn't keep the board and the mechanical model in sync.

## Troubleshooting

* **KiCad doesn't appear in Adam:** update Adam Connector to the latest version.
* **KiCad shows as not connected:** ask Adam to work in KiCad; it will try to open the detected installation. If its location cannot be found, open KiCad once so Adam can find and remember it. Adam keeps that location across restarts and shows Installed while KiCad is closed, as long as the executable still exists. If it still doesn't connect, check the reported runtime error and confirm you are running KiCad 10 with its bundled Python.
* **Adam says KiCad's API is not reachable:** turn on **Enable KiCad API** (see step 3), then open the PCB editor.
* **Adam's schematic changes don't show:** use **File → Revert** in the schematic editor.
* **An edit timed out or KiCad closed during an edit:** the change may have been made. Ask Adam to inspect the project before trying again; Adam never repeats an edit automatically.


# Connect native simulation applications
Source: https://docs.adam.new/integrations/native-cae

Use a licensed Windows simulation application through the Adam Desktop Connector.

Connect a native application when your work depends on its existing study, solver, model format, or installed environment. Adam's connector prepares the integration on your Windows workstation; you supply the application and its required license.

> [!NOTE]
>
> Native CAE workflows are still being qualified across licensed applications and releases. A ready connection confirms access, while the requested study and engineering result need their own checks. Validate a representative copy of your model and confirm version-specific requirements for your workflow.

## Choose the connection

| Integration in Adam | Applications and setup notes |
| - | - |
| SOLIDWORKS | Simulation shares the SOLIDWORKS connection. Install the Simulation add-in and provide the appropriate license. |
| Ansys | Groups Mechanical, Fluent, Workbench, SpaceClaim, Discovery, and LS-DYNA. Install only the applications you use. |
| Abaqus/CAE | Live integration requires Abaqus 2024 or later with Python 3. |
| COMSOL Multiphysics | Runs COMSOL model Java in a COMSOL that Adam opens for you (a COMSOL Desktop connected to a local server), or in batch in a separate COMSOL with no window. Needs `comsolcompile`, `comsolbatch`, `comsolmphserver`, and `comsolmphclient` from the same installation. |
| Simcenter STAR-CCM+ | Runs Java macros in the simulation you have open in STAR-CCM+, or in batch in a separate STAR-CCM+ with no window. |
| Altair HyperMesh | Live integration requires HyperMesh 2026.1 or later. |

LS-DYNA runs batch jobs and doesn't connect to a window you have open. Supported operations in the other applications depend on their native APIs and installed release.

## Match the workflow to the integration

| Path | Implemented workflow scope |
| - | - |
| Mechanical | Scripts in a Mechanical window open on your workstation, or in a separate background Mechanical with no window for solves. Adam's Mechanical extension lets windows you open connect; restart Mechanical once after it installs. |
| Fluent | PyFluent scripts in a Fluent window open on your workstation, or in a separate background Fluent with no window for solves. Fluent 2025 R1 or later. Adam adds a startup hook to your Fluent startup file (`.fluent` in your user folder) so windows you open connect; restart Fluent once after it installs. |
| Workbench | Scripts in a Workbench window open on your workstation, or in a separate background Workbench with no window for updates. Adam's Workbench extension lets windows you open connect; it installs once Workbench has run on the workstation, then restart Workbench once. |
| SpaceClaim and Discovery | Geometry scripts in a SpaceClaim or Discovery window open on your workstation, or in a separate background instance with no window. Adam's add-in, built on your workstation when the integration installs, lets windows you open connect. It goes into each Ansys release's install folder, so Windows asks for administrator rights once; if you decline, select **Install** on the integration to try again. Restart open windows once after it installs. A Discovery connection does not establish support for its simulation fields. |
| Abaqus/CAE and HyperMesh | Model inspection, queries, and scripts in the Abaqus/CAE or HyperMesh window open on your workstation, through Adam's plugin, or scripts in a separate background run with no window. The connector installs the plugin; Abaqus/CAE loads it when it starts, and HyperMesh must be closed while it installs. |
| LS-DYNA | Keyword decks solved in a separate LS-DYNA with no window, from the Ansys installation; the run's files and its termination are reported back |
| COMSOL and STAR-CCM+ | Java model code or macros in the model or simulation you have open, or in a separate application with no window; the files each run writes in its own folder, and the end of its logs, are reported back |
| SOLIDWORKS Simulation | Study inspection and guarded static mesh, solve, and displacement helpers through the SOLIDWORKS bridge |

These paths do not provide the same operations. In particular, HyperMesh preprocessing does not by itself run a downstream solver, and SOLIDWORKS CAD connectivity does not establish that a requested Simulation study type is supported. Ask Adam to inspect the available operations for the intended workflow before changing a study.

## Set up the workstation

**1. Install and verify the native application**

Use the Windows workstation where the application is installed. Confirm it starts and that you can use the required license or module.

**2. Pair the Desktop Connector**

Open the application's integration in Adam and follow the [pairing steps](/integrations/desktop-connector#pair-a-workstation).

**3. Allow the integration to install**

The connector installs Adam's extension, add-in, plugin, or startup hook for the application by itself. Built-in entries do not require a separate Python installation or a custom MCP address. If an install can't finish by itself, select **Install** on the integration to try again.

**4. Complete any application-specific step**

Follow restart instructions shown by the connector. Save your work before restarting an application.

**5. Verify the model with a read-only request**

Confirm the application version, native session, and intended study or model before changing it.

Some Ansys preparation paths depend on native scripting entitlements or permissions in the installation directory. If preparation fails, preserve its diagnostic message and confirm the installed release and permissions with your administrator or Adam support.

## Understand readiness

| Observation | What it establishes |
| - | - |
| An installation is detected | The application appears to be installed |
| The integration installs | Adam's extension, add-in, plugin, or hook is in place |
| A native session connects | Adam can communicate with that session |
| A model is read successfully | Adam can inspect the selected model |
| A solve finishes | The solver reports a completed run; numerical and engineering checks remain |

Detection does not test license availability.

```text title="Inspect a native simulation session" wrap theme={null}
Check my connection to [application] on [computer]. Identify the application version and open model or study. Read its analysis type, geometry identity, and existing results where available. Keep this read-only and distinguish connection readiness from solver or license availability.
```

## Recover without duplicating work

If a connection drops during an operation, the native application may still be running. Ask Adam to inspect the current job, document, and output state before retrying. Cancellation support differs by application; verify that the native solver has stopped.

For preparation problems, include the application and version, connector status, task URL, and non-secret error text when contacting [support](/resources/troubleshooting#contact-support).

Next: [Study setup](/cae/study-setup), [Structural analysis](/cae/structural-analysis), [Fluid analysis](/cae/fluid-analysis), or [Simulation troubleshooting](/cae/troubleshooting).


# Connect Siemens NX
Source: https://docs.adam.new/integrations/nx

Pair your Windows workstation and verify the NX work part.

Connect Siemens NX to inspect geometry, create and edit native models through NX Open, and capture the native viewport. Adam connects to NX on your Windows workstation through its bundled bridge.

## Before you begin

* Use a Windows workstation with a working, licensed NX installation.
* Install the Desktop Connector under the same Windows account as NX.

## Connect

**1. Pair the NX workstation**

In Adam, open **Integrations > Siemens NX** and follow [Desktop Connector setup](/integrations/desktop-connector#pair-a-workstation). Reuse the existing pairing if this workstation is already connected to your Adam account.

**2. Load the bundled bridge**

Open NX normally. If NX was already open during connector installation, save your work and restart NX once so the registered Adam bridge can load.

**3. Open and verify the work part**

Wait for NX to finish starting, open the intended part, and keep NX and the connector running. Check access with the read-only request below.

```text title="Check the NX work part" wrap theme={null}
Inspect the current NX session without changing it. Report the work part, displayed part, units, and any existing update errors you can read. If the work part and displayed part differ, explain which part would receive an edit and wait for me to confirm it.
```

## Use the connection

Specify the work part, dimensions, and geometric constraints in your request. For a change to an existing design, identify the features and interfaces to preserve, then ask for an update and measurement check. Use [CAD modeling](/cad/modeling) or [drawing to model](/cad/drawing-to-model) to structure the task.

## If it does not connect

* **The workstation is paired but NX is unavailable:** confirm that NX and the connector use the same Windows account, then save and restart NX if it was open during installation.
* **The wrong part is active:** confirm the work part and displayed part before requesting changes.
* **A modeling job was interrupted:** ask Adam to inspect the current job and model state before retrying an operation.

For workstation replacement or shared-task routing, see [Desktop Connector troubleshooting](/integrations/desktop-connector#if-an-application-is-offline).


# Connect Onshape
Source: https://docs.adam.new/integrations/onshape

Connect your Onshape account and optionally add Adam inside Onshape.

Connect your Onshape account to work with your Onshape documents from Adam on the web.

You can also add Adam inside Onshape so it knows which document you are viewing and what you have selected.

## Connect your account

**1. Open Onshape in Integrations**

In Adam, select **Integrations**, search for **Onshape**, and open the connection.

**2. Connect your account**

Select **Connect**. Sign in to Onshape if needed, review the requested access, and approve the connection.

**3. Confirm the connection**

Return to Adam and verify Onshape appears under **Connected**.

Adam can work with documents, Part Studios, assemblies, and drawings that your Onshape account can access.

## Add Adam inside Onshape

Install Adam from the [Onshape App Store](https://cad.onshape.com/appstore/apps/Design%20%26%20Documentation/690a8dc864e816c112aa66a0), then open it from an Onshape document and sign in with the same Adam account.

Use the extension when you want to work with Adam without leaving Onshape. Tasks you start there are also available in the Adam web app.

> [tab] Web connection
>
> Best for starting Onshape work from Adam on the web. Onshape does not need to remain open for the account connection to be usable.

> [tab] Onshape extension
>
> Best for starting work from inside Onshape. Keep the Onshape tab open while Adam works with the document.

## Try an engineering workflow

Start with [CAD modeling](/cad/modeling) to create or change a part, [Engineering drawings](/cad/drawings) to prepare a drawing, or [Drawing review](/cad/drawing-review) to inspect an existing one. Include the document link, workspace or version, element, and configuration when they matter to the request.

For a drawing update, check the intended source revision before refreshing its references, then review dimensions and the exported PDF again.

## Disconnect Onshape

Open **Integrations** → **Connected**, select Onshape, and disconnect the account. You can also revoke Adam from your Onshape account settings.

## If connection fails

* Allow the Onshape sign-in pop-up and retry from the Onshape integration card.
* Confirm you connected the intended Onshape account and Adam team.
* If Adam can open Onshape but not a document, check that account's document permission.
* If the extension cannot see your document or selection, reload the Onshape tab and sign in again.

See [Troubleshooting](/resources/troubleshooting) for service-status and support steps.


# Connect Rhino
Source: https://docs.adam.new/integrations/rhino

Connect Rhino 8 on macOS or Windows using the bundled Adam plug-in.

Connect Rhino 8 to inspect the open document, create and edit geometry and layers, build Grasshopper definitions, run RhinoScript, and capture viewports. Adam uses its Rhino plug-in through the Desktop Connector.

## Before you begin

Install Rhino 8 on the macOS or Windows computer you will pair with Adam. Open the model you want to work with and confirm its units before requesting geometry changes.

## Connect

**1. Pair the Rhino computer**

In Adam, open **Integrations > Rhino** and follow [Desktop Connector setup](/integrations/desktop-connector#pair-a-workstation). Use the existing pairing if this computer is already connected to your account.

**2. Install the bundled Rhino plug-in**

Open Adam Connector and use its Rhino setup to install the plug-in. Follow any restart instructions shown by the connector. The Rhino integration in Adam directs you to the connector for this step.

**3. Open and verify the model**

Keep Rhino and the connector running. Open the intended document, check the Rhino connection status, and use the read-only request below.

```text title="Check the Rhino document" wrap theme={null}
Inspect the open Rhino document without changing geometry or settings. Report its name, units, absolute tolerance, layers, and object types where available. Capture the current viewport and identify the objects relevant to [goal] before proposing changes.
```

## Use the connection

Name the objects or layers Adam should work on, the required dimensions, and the geometry to preserve. For Grasshopper work, describe the inputs, intended output, and which parameters should remain editable. Review the resulting geometry in Rhino and request measurements alongside viewport captures. See [CAD modeling](/cad/modeling) and [mesh to CAD](/cad/mesh-to-cad) for complete workflows.

## If it does not connect

* **Adam says to open the connector:** complete the Rhino plug-in setup in Adam Connector.
* **The device is online but Rhino is unavailable:** confirm that Rhino 8 and the plug-in are running on the paired computer, and follow any pending restart instruction.
* **The wrong geometry is targeted:** identify the document, layers, and objects explicitly, then repeat the inspection.
* **An edit was interrupted:** inspect the current geometry before asking Adam to repeat the operation.

For pairing and shared-task ownership, see [Desktop Connector troubleshooting](/integrations/desktop-connector#if-an-application-is-offline).


# Connect Solid Edge
Source: https://docs.adam.new/integrations/solidedge

Connect Solid Edge on Windows to inspect designs, run Automation scripts, and capture the current view.

Connect Solid Edge to inspect your open document, run Solid Edge Automation scripts, and capture its current view. No separate plug-in is required.

## Before you begin

Use a Windows PC with Solid Edge installed and licensed. Open the part, assembly, or drawing you want to work on. For your first connection check, use a copy.

## Connect

**1. Connect your computer**

In Adam, open **Integrations > Solid Edge** and follow [Desktop Connector setup](/integrations/desktop-connector#pair-a-workstation). If this computer is already paired, use the existing connection.

**2. Open your document**

Keep Solid Edge and Adam Connector running on the same Windows PC, with the document you want to work on open.

**3. Check the open document**

Once connected, ask Adam to inspect the document without making changes.

```text title="Check the Solid Edge connection" wrap theme={null}
Inspect my open Solid Edge document without changing it. Report its name and type, the Solid Edge version, and what information you can read. Capture the current view if available. Note anything you cannot inspect.
```

## Work with your design

Describe the change you want, including dimensions or other requirements. Check the resulting design and keep the task output if something fails. See [CAD modeling](/cad/modeling) for guidance on requesting and checking changes.

## If it does not connect

* **The device is online but Solid Edge is unavailable:** open Solid Edge and its document on the paired Windows PC, then check the application's status.
* **A tool cannot read or change the document:** retain the application version, document type, requested operation, and error for [support](/resources/troubleshooting).
* **An operation stopped partway through:** inspect the document before retrying.

For help with pairing, connection issues, or changing computers, see [Desktop Connector troubleshooting](/integrations/desktop-connector#if-an-application-is-offline).


# Connect SOLIDWORKS
Source: https://docs.adam.new/integrations/solidworks

Connect licensed SOLIDWORKS on Windows, verify the active model, and start a CAD task.

Connect SOLIDWORKS to inspect the active model, read and edit dimensions and parameters, run macros, and capture the viewport. Adam uses SOLIDWORKS on your Windows workstation through the Desktop Connector.

## Before you begin

* Install and license SOLIDWORKS on the Windows PC where you will run the connector.
* Open the part, assembly, or drawing you want Adam to work with.
* For Simulation work, you also need the installed Simulation add-in and the appropriate license.

## Connect

**1. Pair the Windows workstation**

In Adam, open **Integrations > SOLIDWORKS** and follow [Desktop Connector setup](/integrations/desktop-connector#pair-a-workstation). If that workstation is already paired to your account, use its existing connection.

**2. Open the intended document**

Keep SOLIDWORKS and the connector running on the paired PC. The SOLIDWORKS bridge is included with the connector; no separate MCP server is required.

**3. Verify model access**

Check the integration's connection status, then run the read-only request below. Confirm the document and configuration before requesting an edit.

```text title="Check the SOLIDWORKS model" wrap theme={null}
Inspect the active SOLIDWORKS document without changing it. Report its name, document type, units, active configuration, and any existing rebuild errors you can read. Confirm that this is the intended model before proposing changes.
```

## Use the connection

For a dimension change, name the feature or parameter, its new value, and any interfaces that must stay fixed. Ask for a rebuild and readback of the changed geometry. See [CAD modeling](/cad/modeling) and [drawing creation](/cad/drawings) for complete requests.

SOLIDWORKS Simulation uses this same connection. Adam can load the installed add-in when a Simulation task starts, and SOLIDWORKS checks the required license. A working CAD connection alone does not establish Simulation availability. Review [native CAE setup and operation scope](/integrations/native-cae) before starting a study.

## If it does not connect

* **The workstation is online but SOLIDWORKS is offline:** open SOLIDWORKS and its document on the paired Windows PC. Check the application status separately from the device status.
* **Adam sees a different model:** identify the document and configuration in your request, then repeat the read-only check before editing.
* **Simulation is unavailable:** check the installed add-in and license, then follow [native CAE troubleshooting](/integrations/native-cae).
* **An edit was interrupted:** inspect the current document before retrying because the previous operation may have changed it.

For device replacement, shared-task ownership, or a disconnected workstation, see [Desktop Connector troubleshooting](/integrations/desktop-connector#if-an-application-is-offline).


# Connect an MCP client
Source: https://docs.adam.new/mcp/connect

Connect ChatGPT, Claude, Claude Code, Codex, or Cursor to Adam and verify workspace access.

Connect your MCP client to the hosted Adam server:

```text theme={null}
https://adam.new/mcp
```

The recommended setup uses OAuth. You do not need to create an API key or
register an OAuth application first.

> [tab] ChatGPT
>
> In a ChatGPT surface that supports custom MCP plug-ins, open **Plugins**, select the plus button, and choose **Add custom MCP server**. Name it **Adam**, enter `https://adam.new/mcp`, and use OAuth authentication.
>
> Create and install the personal plug-in, then complete Adam's sign-in, workspace selection, and permission review. Invoke it from a Work chat to run the read-only connection check below. Custom plug-in access can depend on your host and workspace policy.
>
> See [OpenAI's custom MCP setup guide](https://developers.openai.com/plugins/quickstart) for the current host flow. This creates a connection to the hosted server; the separately packaged [Adam plug-in preview](/mcp/plugin) also includes workflow skills.

> [tab] Claude
>
> **1. Add a custom connector**
>
> Open **Customize > Connectors** and add a custom web connector named **Adam** with `https://adam.new/mcp` as the server URL. Depending on your Claude version, the entry may appear under **Add > Custom > Web** or **Add custom connector**.
>
> **2. Use OAuth and automatic registration**
>
> Choose a sign-in option. If Claude asks how to identify its OAuth client, choose **Register automatically**. Adam supports automatic registration, so you do not need your own Client ID or secret.
>
> **3. Connect Adam**
>
> Start the connection, sign in to Adam, choose the workspace Claude may
> access, and approve the permissions.

> [tab] Claude Code
>
> Add Adam for your user account:
>
> ```bash theme={null}
> claude mcp add --transport http --scope user adam https://adam.new/mcp
> ```
>
> Start Claude Code, enter `/mcp`, select **adam**, and authenticate. Sign in
> to Adam, choose a workspace, and approve the permissions.
>
> See [Claude Code's MCP guide](https://code.claude.com/docs/en/mcp) for client configuration and scope options.

> [tab] Codex CLI
>
> Add the remote server, then start the OAuth connection:
>
> ```bash theme={null}
> codex mcp add adam --url https://adam.new/mcp
> codex mcp login adam
> ```
>
> Sign in to Adam, choose a workspace, and approve the permissions. The
> server is then available to Codex as `adam`.
>
> Use `codex mcp list` or `/mcp` to inspect the connection. See [OpenAI's MCP guide](https://developers.openai.com/codex/mcp) for desktop and IDE setup options.

> [tab] Cursor
>
> Add Adam to `.cursor/mcp.json` in your project, or `~/.cursor/mcp.json` for your user account:
>
> ```json theme={null}
> {
>   "mcpServers": {
>     "adam": {
>       "url": "https://adam.new/mcp"
>     }
>   }
> }
> ```
>
> Enable the server in Cursor, then complete the Adam sign-in, workspace
> selection, and permission screens.
>
> See [Cursor's MCP guide](https://cursor.com/docs/mcp) for current configuration and authentication options.

> [tab] Other clients
>
> Use these connection settings:
>
> | Setting | Value |
> | - | - |
> | Transport | Streamable HTTP |
> | Server URL | `https://adam.new/mcp` |
> | Authentication | OAuth 2.1 with PKCE |
> | Client registration | Automatic registration supported |
>
> Adam publishes the discovery metadata the client needs. If your client
> cannot use OAuth but supports custom HTTP headers, you can instead send a
> [personal API key](/api-reference/introduction) as
> `Authorization: Bearer <key>`.

For managed Claude workspaces, an authorized administrator may need to add the connector before members connect their accounts. Follow [Claude's current custom connector guide](https://support.claude.com/en/articles/11175166-get-started-with-custom-connectors-using-remote-mcp) if the controls differ.

## Verify the connection

```text title="Check Adam access before starting work" wrap theme={null}
Use Adam to identify my connected workspace and granted permissions. If permitted, list existing tasks and integrations. Keep this read-only; do not start an Adam task or run an engineering operation.
```

Check that the returned workspace is the one you intended. If you plan to use desktop CAD, verify the [application connection](/supported-software) separately. MCP sign-in does not install or pair a CAD application.

## What you approve

During OAuth, Adam asks you to choose one workspace. The permission screen may
include project, task, file, billing, integration, automation, and tool-execution access. Tools that are not covered by the connection's effective permissions do not appear to the client.

`tools:execute` enables [direct tool execution](/mcp/direct-tools), including commands, connected accounts, paired devices, stored credentials, and billable tools. It grants broader authority than the individual read/write scopes. Workspace administrators can disable API/MCP access or block permissions for both new and existing connections.

To remove access, open **Settings → Developer → Connected apps** in Adam and
revoke the client. You can also remove its configuration in the client. Connect again to choose a different workspace or request a different set of permissions allowed by the workspace.

> [!WARNING]
>
> Only connect clients you trust. An approved client can read or change data in
> the selected workspace within the permissions shown by Adam.

## Troubleshooting

> [accordion] The client asks for an OAuth Client ID
>
> Use automatic registration instead of a manually registered client. In Claude, choose **Register automatically** if that option appears. Confirm the exact URL `https://adam.new/mcp` and update the client if needed. Do not invent a Client ID or paste an API key into that field.

> [accordion] The wrong workspace is connected
>
> Disconnect Adam in the MCP client and reconnect it. Choose the intended
> workspace on the Adam authorization screen.

> [accordion] A capability is unavailable
>
> Check the connection's effective permissions and the workspace's **Admin > API & MCP** policy. If the workspace allows the capability, reconnect and approve its required scopes. Reconnecting cannot override blocked permissions. For direct calls, also check task ownership and `tools:execute` access.

> [accordion] An administrator has disabled API or MCP access
>
> Ask a workspace owner or admin to review **Admin > API & MCP**. They can disable all API/MCP access or individual permissions. This applies to existing connections too; reinstalling the client will not restore blocked access.

> [accordion] The task panel or CAD viewer does not appear
>
> Ask explicitly to show the task or CAD model. The host must support the relevant MCP Apps interface. Ordinary MCP tools can still retrieve task data in clients without panels. Host attachment previews additionally need the plug-in file-viewer entry point; see [plug-in requirements](/mcp/plugin).

> [accordion] A task has not finished
>
> Adam tasks can continue working after the initial request. Ask the client to
> check the existing task rather than starting it again. Clients with live
> progress support do this automatically.

> [accordion] The client receives a rate-limit error
>
> Wait for the retry time shown by the client before continuing. Repeatedly
> requesting the same task or list can exhaust the connection's allowance.

> [accordion] A direct tool call ended with an unknown outcome
>
> Keep its call ID and inspect the task, files, and native document before retrying. The operation may already have taken effect. Do not automatically submit it again with a new idempotency key. Follow [direct tool recovery](/mcp/direct-tools#read-the-result-before-continuing).

If the connection still fails, check [Adam status](https://status.adam.new) or
contact [hello@adam.new](mailto:hello@adam.new).


# Run Adam tools from your AI client
Source: https://docs.adam.new/mcp/direct-tools

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. This gives the client access to Adam's execution environment while keeping the work, files, and history in one task. Each direct tool call runs without starting an Adam agent loop.

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.

> [!NOTE]
>
> `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 title="Inspect tools without running them" wrap theme={null}
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.
```

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.

## Run a controlled operation

```text title="Use Adam tools in the same task" wrap theme={null}
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 |
| Create a task for client-driven work | `adam_create_external_task` | `tasks:write` |
| Discover tools and their schemas | `adam_list_task_tools` | `tasks:read` |
| Queue one operation | `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 tool name and input schema returned by discovery. Do not create a new task for each operation.

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).


# Adam MCP
Source: https://docs.adam.new/mcp/overview

Use Adam from another AI client, choose who drives the work, and review engineering results in one task.

Adam MCP connects an AI client to your Adam workspace. Browse existing projects and tasks, run engineering work, and collect its files from the client you already use.

```text title="Hosted MCP server" theme={null}
https://adam.new/mcp
```

> [!WARNING]
>
> Adam MCP is in beta. Tools, schemas, behavior, and availability may change, including breaking changes. Check the result of each operation before using it in an engineering workflow.

> [card] [Connect a client](/mcp/connect)
>
> Set up ChatGPT, Claude, Claude Code, Codex, Cursor, or another MCP client.

> [card] [Adam plug-in](/mcp/plugin)
>
> Learn about the private preview package, workspace browser, and CAD viewer.

> [card] [Capabilities and permissions](/mcp/tools)
>
> Check what your connection can read, change, and execute.

> [card] [Use tools from your client](/mcp/direct-tools)
>
> Let your client control individual tools inside an Adam task.

## Choose how work runs

| Mode | Who directs the work | What happens in Adam |
| - | - | - |
| **Delegate to Adam** | Adam's agent | Your client starts or continues an Adam task. Adam works asynchronously and may ask for input. |
| **Use Adam's tools from your client** | The AI client you are using | Your client discovers and calls tools in a task you own. Each direct call runs without an Adam agent loop. |

Both modes keep work in an Adam task with history, files, and project context. You can continue the same task across clients. Wait for active work to finish before switching who controls the next operation.

Creating an empty task for client-driven work does not start inference or provision compute. Executing tools or delegating work can consume Adam usage. [Direct tool execution](/mcp/direct-tools) requires an additional permission with broad access to Adam's execution environment.

## Start with a connection check

After [connecting](/mcp/connect), try this before starting work:

```text title="Verify the connected workspace" wrap theme={null}
Check my Adam connection. Report the selected workspace and granted permissions. If allowed, list my existing projects and connected CAD integrations. Keep this read-only and do not create a task or run an engineering tool.
```

The result should identify the intended workspace. A missing CAD connection does not prevent browsing existing tasks or files. To work inside a native CAD application, set up that application's [Adam integration](/supported-software) and keep any required workstation, application, and license available.

## Delegate an engineering task

```text title="Ask Adam to review a design brief" wrap theme={null}
Start an Adam task to review a design brief for a compact two-stage gearbox. Identify the requirements needed before modeling, the main design risks, and the checks needed to validate a design. Use an available Adam model and keep me updated until the task finishes or needs my input.
```

Clients with MCP Tasks support can monitor Adam's work automatically. Other clients can check the existing task when you ask. If Adam requests input, answer the question or approval in that task, then continue it. Reuse the task rather than starting a duplicate when you return later.

## Open tasks and results

Ask to **open my Adam projects and tasks** or **show this Adam task** when you want a panel. Clients with MCP Apps support can display the workspace browser or task conversation, including supported questions, approvals, and files. Starting or checking a task does not automatically open a panel. Clients without these interfaces can still use the ordinary MCP tools.

For output files, use the client's native file resources for text, source code, images, and PDFs. Ask to show a CAD model to open Adam's interactive viewer in a compatible client. Adam-stored models support STEP, STL, IGES, GLB, GLTF, and 3MF; GLB and GLTF must contain their referenced resources.

Opening a local attachment through the plug-in's viewer is a separate, read-only path with different format and size limits. It does not upload the file into Adam. See [plug-in file previews](/mcp/plugin#preview-a-cad-attachment).

## Access and workspace controls

OAuth connects you to one Adam workspace. Your granted permissions, workspace policy, task ownership, and connected integrations determine what you can do. Workspace administrators can disable API/MCP access or block individual permissions, including direct tool execution.

Review or revoke the connection in **Settings > Developer > Connected apps**. For missing tools or authorization failures, follow [connection troubleshooting](/mcp/connect#troubleshooting).


# Adam plug-in for ChatGPT and Codex
Source: https://docs.adam.new/mcp/plugin

Use the private preview plug-in to browse Adam work, continue a task, and inspect CAD files in a compatible host.

The Adam plug-in packages the Adam MCP connection with setup and engineering workflow skills for ChatGPT and Codex. In a compatible host, it adds entry points for Adam's project and task browser and a read-only CAD attachment viewer.

> [!NOTE]
>
> The packaged Adam plug-in is a private preview. Contact [hello@adam.new](mailto:hello@adam.new) for access and installation instructions for your client. You can connect to the [hosted MCP server](/mcp/connect) without this package. A custom MCP connection does not install the package's bundled skills.

## Connect the preview package

**1. Install the package supplied by Adam**

Follow the installation instructions supplied with the preview for your host and version. The workspace browser and file entry points require compatible plug-in and MCP Apps support; their availability varies by client.

**2. Authenticate the Adam connection**

Use the host's Adam connection flow to sign in, select the intended workspace, and review permissions. Use the sign-in screen for credentials, not the conversation.

**3. Verify access without starting work**

Ask the client to check the connected workspace and list existing work where permitted. Setup does not require creating a task or running a CAD operation.

```text title="Open existing Adam work" wrap theme={null}
Check which Adam workspace is connected, then open my projects and tasks. Show existing work only. Do not create a new task or start an Adam agent.
```

## Browse and continue a task

Open Adam from the host's app navigation where available, or ask to open your Adam projects and tasks. Select a task to inspect its conversation and files. Project browsing requires project read access; task and file access have their own permissions.

The task you select supplies context to the client. The plug-in's composer sends your request to that client so it can continue using Adam's tools. To delegate the next turn to Adam's agent, say so explicitly. Both paths can continue the same task, and execution can consume Adam usage. See [the two execution modes](/mcp/overview#choose-how-work-runs).

Attach input files through the host conversation. The plug-in panel's composer does not accept attachments directly. If the work needs a file inside Adam, ask the client to upload and attach it to the intended task.

## Preview a CAD attachment

In hosts that expose the file-viewer entry point, open a supported attachment with Adam's 3D model viewer.

| File source | Supported preview formats | Behavior |
| - | - | - |
| Attachment supplied by the host | STL, STEP/STP, IGES/IGS, 3MF, up to 32 MiB | Read-only preview. Opening it does not upload it to Adam or modify the file. |
| File already stored in Adam | STEP, STL, IGES, 3MF, and self-contained GLB/GLTF | Open from the task or ask to show the model, using the connection's file access. |

GLB and GLTF are not supported by the host-attachment entry point. Ordinary documents, images, text, and code use the host's native preview. If you want Adam to edit or analyze an attachment, specify the task and request that work separately from opening its preview.

## Connect your CAD application

The plug-in connects your AI client to Adam. Working in an existing SOLIDWORKS, NX, Inventor, CATIA V5, Solid Edge, Rhino, Fusion, or Onshape model also requires the corresponding [CAD connection](/supported-software).

The directory submission candidate uses a dedicated `/mcp/chatgpt` connection with individually exposed file-based CAD tools. File-based modeling can run without a desktop CAD connection. Work inside a connected native CAD application requires an explicit request to delegate to Adam. The manually configured `/mcp` connection retains its existing direct-tool interface. The package remains a private preview until review and publication are complete.

## Troubleshooting

* **No Adam panel or file-viewer entry:** check host support and the preview installation instructions. A working MCP connection alone does not guarantee every plug-in interface is available.
* **Projects, tasks, or files are missing:** check the selected workspace and the relevant read permissions. Workspace administrators can restrict API/MCP access.
* **Opening a local file did not add it to Adam:** previewing is read-only. Ask to upload and attach the file when your task needs it.
* **Tools are listed but cannot run:** check [direct execution permissions and requirements](/mcp/direct-tools#before-you-begin), native application readiness, and available Adam usage.

For sign-in, workspace selection, and revocation, use [MCP connection troubleshooting](/mcp/connect#troubleshooting).


# MCP capabilities and permissions
Source: https://docs.adam.new/mcp/tools

Learn what a connected AI client can do in Adam and which permissions control access.

Adam MCP lets a connected AI client work with the projects, tasks, files, and
automations in your selected workspace. The client only receives the
capabilities covered by the permissions you approve and the workspace's current policy. Ownership, project access, subscription, and integration requirements still apply.

## Permission names

| Area | Read | Change |
| - | - | - |
| Projects | `projects:read` | `projects:write` |
| Tasks | `tasks:read` | `tasks:write` |
| Files | `files:read` | `files:write` |
| Automations | `automations:read` | `automations:write` |
| Billing summary | `billing:read` | No billing-management scope |
| Integration status | `integrations:read` | No integration-management scope |

Direct execution additionally uses `tools:execute`. This is broad authority to run tools, including commands, connected accounts, paired devices, stored credentials, and billable operations. It is not limited to the individual resource scopes above. See [direct tool execution](/mcp/direct-tools) before enabling it.

## Workspace information

An authenticated, allowed connection can identify the selected workspace and list Adam models. Starting a model-driven task also requires task write access and the relevant usage entitlement. Optional read access can let the client:

* view the workspace's current plan and high-level usage;
* see which integrations are available and connected; and
* inspect existing automations and their latest status.

Payment details, provider credentials, and private connection metadata are not
included.

## Projects

| Access | What the client can do |
| - | - |
| Read | Find projects and inspect their names, descriptions, and visibility. |
| Change | Create projects, rename them, and update their details. Moving a task between projects uses task write access. |
| Delete | Permanently delete a project after you confirm the action. Existing tasks and files are kept but become ungrouped. |

## Tasks and conversations

| Access | What the client can do |
| - | - |
| Read | Find tasks, inspect their status, review the conversation, and identify work that needs input. |
| Change | Start tasks, continue existing conversations, rename or reorganize tasks, answer questions, approve actions, and cancel work. |
| Delete | Permanently delete a task and its conversation after you confirm the action. |

Adam tasks may continue after the initial request. Compatible clients show live
progress and keep following the same task until it finishes, needs input, or is
cancelled. Other clients can check the task when you ask for an update.

When you ask a client to create a task, describe the work Adam should perform.
For example, “Create a new Adam task that says hello” should result in a task
whose instruction is “Say hello,” rather than an instruction to create another
task.

## Direct tool execution

With task read access, your client can discover tool names and schemas for a main task you own. With task write access and `tools:execute`, it can queue individual operations without starting an Adam agent loop. Reading a tool-call result or inspecting a child task requires both `tasks:read` and `tools:execute`.

Creating an external task does not start inference or provision compute. Executing tools can use connected accounts and devices and consume usage. The full workflow, ownership requirements, statuses, and retry rules are covered in [Direct tool execution](/mcp/direct-tools).

## Files

| Access | What the client can do |
| - | - |
| Read | Find files attached to projects or tasks, open common formats with the client's native file experience, and inspect supported CAD models in Adam's interactive 3D viewer. |
| Change | Attach a local file to a task or add a shared file to a project. |
| Delete | Remove a shared project file after you confirm the exact file. Task results and conversation attachments are kept with their task. |

Files stay protected by your Adam connection. Compatible clients can open them
directly in the conversation without requiring a separate public download
link. Support for local uploads, downloads, and previews varies by client and
file type.

When you ask to view a STEP, STL, IGES, GLB, GLTF, or 3MF model, clients with
MCP Apps support can show Adam's orbitable 3D viewer in the conversation.
GLB and GLTF files need to contain their referenced resources.
Ordinary files such as source code, text, images, and PDFs continue to use the
client's native preview instead.

The plug-in's host-attachment viewer is a separate read-only path: STL, STEP/STP, IGES/IGS, and 3MF up to 32 MiB. It does not upload attachments into Adam. See [plug-in file previews](/mcp/plugin#preview-a-cad-attachment).

Uploading a task attachment uses `files:write`; attaching it while starting or continuing a task also requires `tasks:write`. Adding or removing a shared project file requires both `projects:write` and `files:write`. Returned API download URLs require authentication; use the client's file resources rather than treating those URLs as public links.

## Automations

| Access | What the client can do |
| - | - |
| Read | Find automations, inspect schedules and triggers, and review their latest status. |
| Change | Create and edit scheduled, one-time, or webhook-triggered work, and pause or resume it. |
| Delete | Permanently delete an automation after you confirm the action. |

## Safety and access

* The connection only acts within the workspace selected during authorization.
* Read and change access are approved separately for each area of Adam.
* MCP deletion tools require an explicit confirmation; deletion uses the corresponding write scope, not a separate delete scope.
* Workspace owners and admins can disable API/MCP access or block scopes under **Admin > API & MCP**. Restrictions apply to existing credentials too.
* `tools:execute` grants broad execution authority beyond individual resource scopes. Administrators can block it with **Allow full harness execution**.
* Revoking the connected app immediately ends its access.
* Removing a person from the workspace also removes access granted through
  their connection.

You can review or revoke connections in **Settings → Developer → Connected
apps**.

## Example requests

```text title="Start engineering work in a project" wrap theme={null}
Find my Adam project for the enclosure redesign, then start a task to review the
latest design for injection-molding risks. Keep me updated until it finishes or
needs my input.
```

```text title="Review completed work" wrap theme={null}
Find the completed tasks in my current Adam project, summarize the results, and
show me any output files I can open.
```

```text title="Manage an automation" wrap theme={null}
Show me my Adam automations. Pause the monthly design review after I confirm
which automation you found.
```


# Your first engineering task
Source: https://docs.adam.new/quickstart

Review a drawing, inspect the findings, and continue into CAD or simulation.

Start with a drawing review. You need an Adam account and a PDF, with no connector or CAD license to install. Use our practice drawing or a file you already know. By the end, you should have a findings table that separates stated dimensions from missing requirements.

## Bring a drawing

Sign in at [adam.new](https://adam.new). Download the [sensor mount practice drawing](/files/examples/sensor-mount-review.pdf), or choose your own PDF with readable dimensions. The practice file is an original learning example with deliberately incomplete manufacturing information.

![Sensor mounting plate SM-001 revision A. Top and front views show two 6.5 mm through-holes. Material, finish, and tolerances are not specified.](https://mintcdn.com/adam-585915d9/dzd7_TgVZCSWXd5w/images/examples/sensor-mount-review.png?fit=max\&auto=format\&n=dzd7_TgVZCSWXd5w\&q=85\&s=193c991fb3fafa5007911e11140eebff)

Practice drawing: a 76 × 38 × 5 mm plate with two through-holes. Download the PDF to read every dimension.

For your own file, have its revision and any applicable review checklist ready. If you want to edit a native model instead, use the [software guide](/supported-software) to connect your CAD application first.

**1. Start a task and attach the file**

Select **New Task**, then use **+**, drag in the drawing, or paste an image. Include all sheets needed to understand the part.

> [accordion] Find the attachment button
>
> ![Adam task composer with a file attachment button and message box](https://mintcdn.com/adam-585915d9/SOvZH_gvRGaOooNN/images/product/new-task-composer.jpg?fit=max\&auto=format\&n=SOvZH_gvRGaOooNN\&q=85\&s=d723f864c52e1a7ada45370843f27c91)
>
> Attach the source file and describe the result you need.

**2. Give Adam a specific review brief**

Copy the request below for the practice drawing. For your own file, change the part name and revision and attach your supplier checklist if you have one.

**3. Check the evidence**

Open the source beside the findings. Verify a few cited dimensions, locations, and notes. An unreadable value should remain an open question.

**4. Refine the result**

Correct a mistaken interpretation or supply a missing requirement in the same task. Ask for the final findings as a table or downloadable report.

```text title="Review a drawing before a design meeting" wrap theme={null}
Review the attached sensor mounting plate drawing SM-001, revision A. Check dimension coverage, hole callouts, units, material and finish notes, and inconsistencies between views. Return a table with the sheet and feature, finding, supporting evidence, and suggested next step. Mark unreadable or unspecified values as unresolved. Use stated dimensions rather than measuring the picture. Keep the source unchanged.
```

## Check the practice result

The wording of Adam's response can vary. Compare its findings with the information actually present in the PDF:

| Item | What the source establishes |
| - | - |
| Envelope | 76 mm long, 38 mm wide, 5 mm thick |
| Holes | Two 6.5 mm through-holes, centered across the width and 12 mm from each short edge |
| Hole-center spacing | 52 mm, derived from 76 − 12 − 12 |
| Manufacturing information | Material, finish, and tolerances are explicitly unspecified |
| Model agreement | Unchecked, because no native model accompanies the drawing |

Missing requirements should be reported as questions for the designer. A response that invents an alloy, tolerance, or manufacturing approval needs correction.

If the file is unreadable, reattach the original PDF or a clearer export. If Adam pauses, answer its question in the task. For connection, usage, or file problems, use [Troubleshooting](/resources/troubleshooting).

## Make the next request precise

A useful request gives Adam the **source**, **goal**, **constraints**, and **deliverable**. For example:

```text title="Follow up on one finding" wrap theme={null}
For the practice drawing, calculate the hole-center spacing using the two end offsets and overall length. Show the equation and units, then update the findings table. Keep material, finish, and tolerances unresolved until I supply requirements.
```

The result should identify what was checked and what still needs your input. A visual review may find a likely problem; confirming it can require the CAD geometry, a readable dimension, or a manufacturing requirement.

## Continue with CAD or simulation

> [card] [Edit a native model](/cad/modeling)
>
> Connect CAD, identify the active document, and make a measured change.

> [card] [Run an engineering analysis](/cae/overview)
>
> Define loads, materials, boundaries, and the result you need.

Keep related follow-ups in the same task. For work across several tasks, put the brief and reference files in a [project](/guides/projects).


# Frequently asked questions
Source: https://docs.adam.new/resources/faq

Answers to common questions about Adam tasks, CAD connections, files, teams, scheduled work, models, and billing.

## Do I need both the Onshape connection and the Onshape extension?

No. Connecting your Onshape account is enough to work with Onshape documents from Adam on the web, even when Onshape is closed. Install the optional extension when you want to use Adam inside Onshape and have it follow the document and selection you are viewing.

## How do I use Adam with Fusion?

Install Adam Connector from [fusion.adam.new/install](https://fusion.adam.new/install). It sets up the Adam add-in for Fusion. Restart Fusion and select **Adam** from the Fusion toolbar.

## Which CAD applications need to stay open?

Keep Fusion and applications connected through the Desktop Connector open while Adam works with them. Onshape does not need to stay open when you start the task from the Adam web app.

## Which CAD and simulation applications can I connect?

See [Supported software](/supported-software) for application coverage, operating-system requirements, connection paths, and preview notes. Native CAD and CAE capabilities vary by application, release, and requested operation.

## How do I connect Siemens NX?

Pair the Desktop Connector on the Windows workstation running NX, using the same Windows account as NX. Follow the [Siemens NX setup guide](/integrations/nx) to load the bundled bridge and verify your work part.

## Can I pair more than one workstation?

Your account has one paired workstation at a time. Pairing a new computer replaces the previous connection. One workstation can serve multiple supported applications. In a shared task, desktop operations use the task owner's workstation.

## Can I run a simulation without connecting a commercial solver?

Adam can use available tools in its task environment, including structural and CFD tooling in updated runtimes. Ask it to check the solver and formulation needed for your study. Commercial native studies require the corresponding installed application and license. Start with [Simulation workflows](/cae/overview).

## Can Adam make or review an engineering drawing?

Yes. See [Engineering drawings](/cad/drawings) for model-derived drawings and [Drawing review](/cad/drawing-review) for checking PDFs or native drawings. Provide the source revision, units, template, and engineering requirements. Native drawing creation depends on the connected application's tools; review the final output before release.

## Where did Adam put a generated file?

Open the task and check its files, or select **Files** in the sidebar to search across tasks. You can filter by file type, who created it, and the product it came from. See [Find and export files](/guides/files).

## Is a task permission the same as a team role?

No. Team roles are **Owner**, **Admin**, and **Member**. A task invitation separately grants **Can view** or **Can edit** for that task. Published task links are read-only.

## Can Adam run something on a schedule?

Yes. Open **Scheduled** to create one-time, hourly, daily, weekly, monthly, or custom recurring tasks. For recurring engineering work, keep the brief and reference files together using [Repeat engineering work](/guides/repeatable-work).

## Why is a model or reasoning option unavailable?

Some model families and reasoning choices require a particular plan or enough remaining usage. All models in a family share its access requirements. Open **Settings** → **Billing** to check your plan and usage. See [Model usage costs](/admin/usage-costs) for more about choosing a model.

## Where are settings?

Open the account menu at the bottom of the sidebar and select **Settings**. The Team tab appears when you are working in a shared team.

## When does included usage refresh?

Daily usage refreshes at midnight UTC. Paid monthly included usage refreshes the first of each month at midnight UTC, separately from the subscription renewal date. Trials use their own usage window. After a self-service paid member's monthly allowance and the workspace's add-on funds are depleted, they can continue with Lite on their daily allowance. Check **Settings** → **Billing** for current usage, or read [Billing and usage](/admin/billing#after-monthly-usage-runs-out).

## Does connecting Codex make every part of a task free of Adam usage?

No. Model usage through the Codex connection does not consume your Adam allowance, but separately metered services such as image generation can still do so. A paid Adam plan is required. See [Use your Codex plan](/admin/usage-costs#use-your-codex-plan).

## Does the auto-reload limit cap every charge?

No. It caps automatic reload purchases for the month. Manual **Add funds** purchases and subscription charges are separate. Auto-reload watches the usage-based balance, even when included monthly usage remains. See [Add-on funds and automatic reload](/admin/billing#add-on-funds-and-automatic-reload).

## Where can I cancel or find an invoice?

Open **Settings** → **Billing** → **Manage**. Choose **View invoice** for subscription invoices, or **Manage subscription** → **Downgrade to Free** to begin cancellation. A shared team must have one member and one seat before it can cancel. See [Cancel or reactivate](/admin/billing#cancel-or-reactivate) for timing and recovery.

## Can I share an Adam result publicly?

The task owner can publish a read-only plain or password-protected link when workspace policy permits public links. Review the conversation and every attachment first, and switch it back to private when public access is no longer needed.

## What happens when I delete a task?

Deletion is permanent. Download or export any outputs you need before deleting it from the task menu.

## Where can I get help?

Check [Troubleshooting](/resources/troubleshooting) and [Adam service status](https://status.adam.new). If the problem persists, email [hello@adam.new](mailto:hello@adam.new) with the task URL, integration name, approximate time, and what you expected to happen. Do not include passwords or API keys.


# Troubleshooting
Source: https://docs.adam.new/resources/troubleshooting

Diagnose task, CAD connection, file, scheduled-work, integration, and billing issues in Adam.

Start by checking [Adam service status](https://status.adam.new). Then check whether the problem affects one task, one connected product, or everything in Adam.

## A task will not start or continue

1. Open the task and check for a question, approval card, or **Needs input** state.
2. Open **Settings** → **Billing** and verify that included usage or add-on funds are available.
3. If the task uses a desktop CAD application, confirm that the application and its Adam connection are open.
4. Retry with a simpler request that names the document, file, or record.

If Adam may have changed something before the error appeared, check the file or record before asking it to try again.

## Onshape will not connect

* Allow the Onshape sign-in pop-up and retry from **Integrations** → **Onshape**.
* Confirm you signed in to the intended Onshape account and active Adam team.
* Check the Onshape account's permission to the target document.
* Disconnect and reconnect Onshape if the account access changed.

If the problem only happens inside Onshape, reload the Onshape tab and sign in to Adam again.

## Fusion appears offline

* Open Fusion and the intended design.
* Select **Adam** in the Fusion toolbar.
* If the button is missing, press **Shift+S**, open **Add-Ins**, find **AdamFusion**, and choose **Run**.
* If AdamFusion is absent, open Adam Connector and install the Fusion add-in, then restart Fusion. Download Adam Connector from [fusion.adam.new/install](https://fusion.adam.new/install) if you do not have it.

## A Desktop Connector application is offline

1. Open the Desktop Connector on the computer running the target application.
2. Start the application and complete any plug-in setup required by its integration card.
3. Confirm the device still appears in the integration detail.
4. If necessary, generate a fresh expiring pairing code and pair again.

SOLIDWORKS, NX, Inventor, CATIA V5, and Solid Edge use Windows connections. If NX was open when its bridge was installed, save your work and restart NX once. Check the [software guide](/supported-software) for application-specific requirements.

Pairing another workstation replaces the previous one. If the wrong computer is shown, pair the intended workstation, then confirm its application status. In a shared task, check the task owner's workstation rather than the computer of the person who sent the latest message.

## An integration is missing or blocked

Workspace administrators can restrict integrations. Check the active workspace and ask an administrator whether that integration is allowed. Reinstalling a connector does not change account access.

## I cannot share a task or project

Check that you own it. Workspace policy can disable collaboration, public task links, or invitations outside the workspace. Ask an administrator to check the workspace and member settings. Projects support invitations and team visibility, but do not have anonymous public links.

## A native simulation application is not ready

Check installation discovery, integration preparation, native session access, and licensing separately. First-time CAE preparation needs internet access; a detected installation does not establish license availability or access to a model. SOLIDWORKS Simulation uses the SOLIDWORKS connection and requires the installed Simulation add-in.

Follow [Native CAE setup](/integrations/native-cae). If a connection drops during a solve, inspect the application's state before retrying. For mesh errors, convergence problems, or implausible numerical output, use [Simulation troubleshooting](/cae/troubleshooting).

## A CAD operation finishes but the result looks wrong

Confirm the source document, configuration, revision, and units. Ask Adam to compare the actual geometry or drawing dimensions with the request. Inspect the current state before repeating an edit that may already have been applied.

Use [Repair a model](/cad/repair) for rebuild or reference failures and [Drawing review](/cad/drawing-review) for annotation, coverage, or layout problems.

## A connected cloud account stopped working

Your sign-in to another product may expire. Open **Integrations** → **Connected**, select the account, and reconnect it. If Adam cannot open one particular file or record, confirm that your account can access it directly.

For an API-key connection, create a new key in the connected product and give it only the permissions Adam needs. Never paste a key into a task or support email.

## An MCP client or plug-in cannot access Adam

Check the workspace selected during sign-in and the connection's effective permissions. In a shared workspace, an owner or admin can review **Admin > API & MCP**. Reconnecting does not restore access disabled by workspace policy.

If ordinary task tools work but direct execution is missing, check `tools:execute` and **Allow full harness execution**. Direct calls require a main task you own. If the task panel or CAD preview is missing, check the host's MCP Apps and plug-in support separately from authentication.

Follow [MCP connection troubleshooting](/mcp/connect#troubleshooting), [direct tool recovery](/mcp/direct-tools#read-the-result-before-continuing), or the [Adam plug-in guide](/mcp/plugin).

## An expected file is missing

* Open the task that created the file and check its file tabs.
* Search **Files** by filename, type, source, or platform.
* Check whether the task paused before file creation.
* Ask Adam whether it finished creating the file before asking it to try again.

## A scheduled task did not run

* Confirm the automation is not paused.
* Review its next run and the time zone shown.
* Open the previous runs to find the latest result or error.
* Confirm that any connected account it needs still works and that your plan has usage available.
* For an event-triggered task, confirm that the expected event happened in the connected product.

To change the event that starts a task, ask Adam to update or recreate it.

## Contact support

Email [hello@adam.new](mailto:hello@adam.new) and include:

* the Adam team and task URL;
* the integration and application version, if relevant;
* the approximate time and time zone;
* the expected result and the result you observed; and
* a screenshot or non-secret error message.

Never send a password, API key, full payment-card number, or Desktop Connector pairing code.


# Set up Adam
Source: https://docs.adam.new/setup

Find your way around Adam and choose the account settings that matter to you.

When you first sign in, Adam creates a personal team for you. You can use it on your own or join a shared team later.

## Learn the navigation

The sidebar contains **New Task**, **Tasks**, **Files**, **Integrations**, and **Scheduled**. It also shows recent tasks. Use the team switcher near the bottom of the sidebar when your account belongs to more than one team.

Open the account menu at the bottom of the sidebar and select **Settings**.

## Configure settings

| Tab | What you can manage |
| - | - |
| **General** | Theme, suggested prompts, model-name display, browser notifications, and your optional Codex connection. |
| **Account** | Your account details, account-management link, sign-out, and account deletion. |
| **Team** | Your shared team's name, seats, invitations, and members. This tab appears when you are in a shared team. |
| **Notifications** | Browser and product notification preferences. |
| **Billing** | Your plan, usage, subscription, payment method, and add-on funds. |
| **Developer** | API keys and connected MCP apps for the selected workspace. See [MCP setup](/mcp/connect). |
| **Memory** | Review or remove information Adam remembers across tasks. |

## Connect your tools

You can use Adam without connecting another product. When you want Adam to work directly with a CAD, PLM, or cloud tool, open **Integrations** and choose it from the list.

* [Onshape](/integrations/onshape) connects to your Onshape account.
* [Autodesk Fusion](/integrations/fusion) uses the Adam add-in for Fusion.
* [SOLIDWORKS](/integrations/solidworks), [Siemens NX](/integrations/nx), [Inventor](/integrations/inventor), [CATIA V5](/integrations/catia), [Solid Edge](/integrations/solidedge), and [Rhino](/integrations/rhino) use the [Adam Desktop Connector](/integrations/desktop-connector). Check each guide for access requirements and preview status.
* [Arena](/integrations/arena) connects to your Arena account.

## Switch between teams

If you belong to more than one team, use the team switcher at the bottom of the sidebar. Your tasks, files, integrations, and billing change with the selected team.

> [!TIP]
>
> You are ready to use Adam when you can open **New Task** and send a message. Connect other tools only when you want Adam to work with them directly.


# Software and connection requirements
Source: https://docs.adam.new/supported-software

Choose a CAD, CAE, electronics, or PLM connection and understand what it requires.

Open **Integrations** to see the connections available to your account. Workspace policy can restrict which integrations you can use. The tables below explain the setup paths and any additional access requirements. The application version, license, open document, and operation you request can all affect what Adam can do.

## CAD and design

| Application | Connection | Requirements and scope |
| - | - | - |
| [Onshape](/integrations/onshape) | Account authorization; optional in-product panel | Access to the intended document. The web connection does not require an open Onshape tab. |
| [Autodesk Fusion](/integrations/fusion) | Adam Connector and Fusion add-in | Fusion running on macOS or Windows with the intended design open. |
| [SOLIDWORKS](/integrations/solidworks) | Desktop Connector | Windows; installed, licensed SOLIDWORKS. Simulation uses this connection and requires its own installed add-in and entitlement. |
| [Siemens NX](/integrations/nx) | Desktop Connector and bundled NX bridge | Windows; use the same Windows account as NX. Save and restart NX if it was open during bridge installation. |
| [Autodesk Inventor](/integrations/inventor) | Desktop Connector | Windows; installed, licensed Inventor. Its bridge is bundled. |
| [CATIA V5](/integrations/catia) | Desktop Connector | Windows; installed, licensed CATIA V5. This connection is for V5. |
| [Solid Edge](/integrations/solidedge) | Desktop Connector, preview | Windows. Native workflows are awaiting qualification on a licensed installation. |
| [Rhino](/integrations/rhino) | Desktop Connector and application setup | Rhino 8 on macOS or Windows; install the bundled Rhino plug-in from Adam Connector and follow any restart instructions. |
| Revit | Desktop Connector and Autodesk MCP setup | Windows; Revit 2027 using Autodesk's Public MCP Server Tech Preview. |
| SketchUp | Desktop Connector | SketchUp 2019 or later on macOS or Windows. The connector installs its SketchUp extension; restart SketchUp once if it was open at the time. |
| Blender | Desktop Connector | Blender 3.2 or later on macOS or Windows. The connector installs its Blender add-on; restart Blender once if it was open at the time. |
| Unreal Engine | Desktop Connector and application setup | Enable the editor's MCP server using the integration card's instructions; keep the editor open. |

For applications without a version range listed here, use the current integration setup and confirm your release with support if you need a compatibility commitment. A connected application does not imply that every command in its interface is automated.

## Simulation

You can ask Adam to prepare and run supported analyses in its task environment or connect a licensed Windows simulation application. These are separate execution paths.

| Path | Tools or applications | What to check |
| - | - | - |
| Adam task environment | Gmsh, CalculiX, scikit-fem, and OpenFOAM in updated runtimes | Ask Adam to check the actual solver, version, and formulation available in your task before a solve. |
| SOLIDWORKS Simulation | Uses the SOLIDWORKS connection | Installed Simulation add-in, appropriate license, and supported study operations. |
| Ansys | Mechanical, Fluent, Workbench, SpaceClaim, Discovery, LS-DYNA | One **Ansys** integration groups these applications. LS-DYNA runs keyword decks in batch; the other entries provide application-specific live-session paths. |
| Abaqus/CAE | Native CAE connection | Live integration requires Abaqus 2024 or later with Python 3. |
| COMSOL Multiphysics | Native CAE connection | Runs COMSOL model Java in a COMSOL that Adam opens for you, or in batch, with a COMSOL license. |
| Simcenter STAR-CCM+ | Native CAE connection | Runs Java macros in your open simulation, or in batch, with a STAR-CCM+ license. |
| Altair HyperMesh | Native CAE connection | Live integration requires HyperMesh 2026.1 or later. |

> [!NOTE]
>
> Native CAE connections are evolving, and licensed application/version qualification remains incomplete. Start with a representative copy of your own model. Check [native CAE setup](/integrations/native-cae) for readiness, licensing, and recovery details before using a connection for a study.

## Electronics and PLM

| Application | Connection | Requirements |
| - | - | - |
| [KiCad](/integrations/kicad) | Desktop Connector | KiCad 10; enable its API for live PCB editing. Follow the save/reload instructions for schematic edits. |
| [Arena PLM](/integrations/arena) | Account connection | An Arena account with access to the intended workspace and records. |
| Custom MCP | Desktop Connector | A trusted local server with a Streamable HTTP MCP endpoint. |

## Confirm the connection before editing

```text title="Check the application and document" wrap theme={null}
Check my connection to [application] on [computer]. Report the application version, active document or model, and whether you can read its contents. Keep this check read-only. If the application or required license is unavailable, explain what is missing before starting the task.
```

For connection failures, use [Desktop Connector setup](/integrations/desktop-connector) or [Troubleshooting](/resources/troubleshooting). For the engineering task itself, browse [CAD workflows](/cad/overview) or [simulation workflows](/cae/overview).