# Billing and usage
Source: https://docs.adam.new/admin/billing
Understand Adam plans, daily and weekly included usage, per-seat limits, add-on funds, and usage-limit behavior.
Open your account menu, select **Settings**, and choose **Billing** to see your plan, usage, payment settings, and charge history.
The Billing page shows how much included usage remains and when it refreshes.
See [Usage costs by tier](/admin/usage-costs) to compare how Lite, Pro, and Ultra use your allowance.
## Compare plans
**Pro** and **Max** are individual plans. Both unlock Adam's paid task tiers and refresh included usage each week. Max is designed for heavier or sustained workloads and includes more weekly 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 weekly allowance from their own Pro or Max seat, and Team Max provides more weekly usage per seat than Team Pro. Add-on funds are shared across the workspace.
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.
## How usage refreshes
* Daily usage refreshes at **00:00 UTC**.
* Paid included usage refreshes each **Monday at 00:00 UTC**.
* On a team plan, paid weekly 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 task tiers available after a member's weekly allowance is depleted.
Adam shows included usage as a percentage on the Billing page.
## After weekly usage runs out
When your paid weekly allowance and the workspace's add-on funds are depleted, Adam switches to a daily allowance for Lite:
* Pro and Ultra are unavailable for new messages in that workspace until paid usage becomes available again.
* 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 weekly allowance resets.
* The Billing page shows Daily usage first, followed by your depleted Weekly usage and your actual Ultra usage for the week.
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 Pro and Ultra available again. Otherwise, wait for your weekly allowance to refresh on Monday. If the daily allowance is also depleted, Lite becomes available again after the next daily refresh.
## Keep using Pro and Ultra
To restore paid model usage before the weekly refresh, you can:
* add funds to the workspace balance;
* turn on automatic reload; or
* upgrade to a plan with more weekly usage.
Otherwise, continue with Lite on your daily allowance or wait for the weekly allowance to refresh.
## Add-on funds and automatic reload
Add-on funds let you continue using Pro and Ultra after your weekly allowance runs out. Use **Add funds** on the Billing page to add money to the workspace balance.
Automatic reload adds a chosen amount when your balance falls below a threshold. Set a limit that matches your expected spending and review the charge history after changing it.
Automatic reload creates real charges. Team owners and admins should review the payment method, threshold, amount, and any reload cap together.
## Manage the subscription
Use **Settings** → **Billing** to upgrade, change seats, add funds, manage automatic reload, review charges, or manage your subscription. On a shared team, the owner and admins manage billing.
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.
**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
Open **Settings** → **Team** and check the current seat count before inviting someone.
Enter the person's email address and choose the appropriate team role.
Pending invitations appear in Team settings. Invitations count toward seat capacity, so revoke an obsolete invite before reusing its seat.
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 weekly 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).
## Leave or remove access
Members can leave a team from Team settings. The owner must transfer ownership before leaving. Contact [hello@adam.new](mailto:hello@adam.new) if you need help changing the owner.
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).
# Usage costs by tier
Source: https://docs.adam.new/admin/usage-costs
Compare how Lite, Pro, and Ultra use your Adam usage allowance.
These are **task tiers**, not subscription plans. Your plan determines which tiers you can use and how much included usage you receive.
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.
**What is Fast mode?** Fast mode increases how quickly supported tiers 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 large context?** Large context applies when a request contains enough instructions, conversation history, or file content to cross the large-context threshold. Affected tiers use more of your allowance beyond that point, which is reflected automatically in the comparison above.
**Token pricing.** Adam does not mark up token usage. We charge it at our underlying cost and, in some cases, charge less than that cost.
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.
Each request is deducted from the included usage provided by your plan. Max includes more weekly usage than Pro, and Team Max includes more usage per paid seat than Team Pro. On team plans, each assigned member uses the weekly allowance for their own Pro or Max seat. Add-on funds are shared across the workspace.
After your weekly allowance and the workspace's add-on funds are depleted, only Lite is available through a small daily allowance until paid usage becomes available again. See [Billing and usage](/admin/billing#after-weekly-usage-runs-out) for the full fallback behavior and refresh times.
# 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.
# API overview
Source: https://docs.adam.new/api-reference/introduction
Build on Adam with 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
```
The Adam API is in beta. Endpoints, schemas, behavior, and availability may
change at any time without prior notice, including breaking changes. Avoid
relying on it for production-critical workflows.
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
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.
You can inspect the user, workspace, scopes, and credential type associated
with a key:
```bash theme={null}
curl https://api.adam.new/v1/auth/context \
-H "Authorization: Bearer $ADAM_API_KEY"
```
Never put an Adam API key in browser code, a mobile app, source control, or a
client-side environment variable.
## Billing and integrations
Keys 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.
Keys 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 version.
Every request consumes from both a global per-key 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 |
| ------------------------------ | --------------------------------------------------------- |
| `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 key |
| `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.
# 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
Select **Scheduled** in the sidebar, then select **New scheduled task**.
Enter the instructions Adam should follow each time. You can also give the task a name.
Select a one-time date, hourly, daily, weekly, monthly, or custom schedule. Check the time zone shown before saving.
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.
## 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.
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.
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.
## 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.
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.
# 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.
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.
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 Adam to CAD applications, Arena, and other tools you use.
Open **Integrations** in the sidebar to find a product or manage an existing connection. Use **Connected** to see the accounts and computers already linked to your team.
## Choose the right connection method
| Connection | How it connects | Keep the application open? |
| ----------------------------------------------------------------------------------- | ---------------------------------------------------------------- | ----------------------------------- |
| [Onshape](/integrations/onshape) | Connect your Onshape account; optionally add Adam inside Onshape | Only when using Adam inside Onshape |
| [Autodesk Fusion](/integrations/fusion) | Install the Adam add-in for Fusion | Yes |
| [SolidWorks, Revit, Blender, SketchUp, and Unreal](/integrations/desktop-connector) | Install the Adam Desktop Connector | Yes |
| [Arena PLM](/integrations/arena) | Sign in to your Arena account | No |
| Other cloud products | Follow the sign-in steps shown in Adam | No |
## Connect an integration
If you use more than one team, select the team that should have access to the connection.
Go to **Integrations**, search for the tool, and open its connection card.
Adam will ask you to sign in, install an add-in, pair a computer, or enter a key depending on the product.
Return to **Connected** and check that the account or computer appears.
## Use an integration in a task
Tell Adam which product, document, or record to use and what you want it to do. If you connected more than one account, say which one you mean.
For important changes, ask Adam to review the work and wait for you before editing anything:
Review \[document or record name]. Summarize what you find and explain what you would change. Do not make changes until I approve them.
## Credentials and access
For integrations that require an API key, use a dedicated key with only the permissions Adam needs. Adam will not display the full key again after you save it.
Disconnect an account from its integration page or the **Connected** view when your team no longer needs it.
Connected products may contain sensitive design or business information. Only connect accounts that the team is allowed to use.
# 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.
Projects are available on paid plans.
## Create a project
Select **Projects** in the sidebar, then select **New Project**.
Use a name that distinguishes this work from your other projects.
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.
Select **Project only** to keep memories inside the project, or **All tasks** to let Adam use them elsewhere in your workspace.
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.
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.
Only tasks in this project can use its memories. Use this for work that should stay isolated from unrelated 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.
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).
# 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.
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.
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.
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.
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 work, create a schedule from [Scheduled tasks](/guides/automations) instead of manually recreating the request.
# Adam documentation
Source: https://docs.adam.new/index
Learn how to use Adam as an AI CAD copilot across tasks, files, CAD applications, PLM systems, and team workflows.
Adam is an AI CAD copilot for hardware teams. Ask a question, attach an engineering file, or connect a supported CAD tool to get help with design and engineering work.
Ask Adam to review a file, answer a question, or help with an engineering task.
Set up Onshape, Fusion, SolidWorks, Arena, or another supported tool.
Continue previous work, find files, and share results with your team.
Check your plan, usage, payment settings, and add-on funds.
## What you can do in Adam
* **Review and change CAD.** Work with supported Onshape, Fusion, and desktop CAD applications.
* **Work with engineering information.** Review drawings, specifications, bills of materials, supplier information, and Arena records.
* **Research and create.** Search the web and create documents, presentations, images, spreadsheets, code, and other files.
* **Keep work organized.** Return to previous tasks, find generated files, share results, and schedule recurring work.
## Where to go
| When you want to... | Go to |
| ------------------------------------- | ---------------------------------------- |
| Start something new | Select **New Task**. |
| Continue previous work | Open **Tasks**. |
| Find or download a file | Open **Files**. |
| Connect a CAD app or another tool | Open **Integrations**. |
| Run a task later or repeat it | Open **Scheduled**. |
| Change your account, team, or billing | Open **Settings** from the account menu. |
## Connect your CAD tools
Connect your Onshape account or add Adam inside Onshape.
Install the Adam add-in and work from Fusion or the Adam web app.
Connect supported applications running on your computer.
Work with items, bills of materials, suppliers, files, and changes.
# 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
In Adam, select **Integrations**, search for **Arena**, and open its connection card.
Sign in with the Arena email address and password for the account Adam should use.
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:
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.
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.
# Use the Desktop Connector
Source: https://docs.adam.new/integrations/desktop-connector
Connect Adam to supported CAD and 3D applications running on your computer.
The Adam Desktop Connector links Adam to supported applications running on your computer, including **SolidWorks, Revit, Blender, SketchUp**, and **Unreal Engine**.
## Pair a desktop application
Select **Integrations**, choose the desktop application, and start its setup flow.
Download and install the Adam Desktop Connector on the computer that runs the target application.
In Adam, generate a new pairing code. Codes expire, so keep the setup window open.
Open the Desktop Connector and enter the code.
Keep the connector and the application open while Adam works with it. Return to Adam and confirm the computer is connected.
## Application notes
SolidWorks support is available on Windows. Start SolidWorks and keep it open while Adam works with it.
Adam currently supports Revit 2027 through Autodesk's Public MCP Server Tech Preview. Follow the Revit setup steps shown in Adam.
Follow the setup steps shown in Adam, then keep the application and Desktop Connector open while Adam works with it.
## Connect a custom MCP server
This is an advanced option for connecting your own local tools. Use **Custom MCP** if your server provides a **Streamable HTTP** MCP endpoint.
Enter the local endpoint URL in the Desktop Connector, verify the server is running, and test it with a read-only request. A command-line stdio server is not a URL and cannot be entered directly; expose a supported HTTP endpoint first.
Only connect servers you trust. Their tools may be able to change files or data on your computer and in other products.
## Manage paired devices
Open the integration page to rename, repair, or unpair a computer. Unpair computers you no longer control.
If a device appears offline:
* open the Desktop Connector on the paired computer;
* confirm the target application and its plug-in are running;
* verify the computer can reach Adam over the network; and
* generate a new pairing code and connect the computer again.
# Install Adam for Autodesk Fusion
Source: https://docs.adam.new/integrations/fusion
Install the Adam add-in and work with Fusion from the in-product panel or Adam web app.
Install the Adam add-in to work with your Fusion designs. You can start a task from inside Fusion or use the Adam web app while Fusion is open.
## Install the add-in
Open [fusion.adam.new/install](https://fusion.adam.new/install) on the macOS or Windows computer where Fusion is installed.
Close Fusion if requested, install Adam, and then restart 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]()
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]()
## 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, rerun the installer 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.
For an important edit, ask Adam to explain the planned changes and wait for your approval before applying them.
## Reinstall or update
Download the installer from [fusion.adam.new/install](https://fusion.adam.new/install) and run it again. Restart Fusion when installation finishes.
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 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
In Adam, select **Integrations**, search for **Onshape**, and open the connection.
Select **Connect**. Sign in to Onshape if needed, review the requested access, and approve 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.
Best for starting Onshape work from Adam on the web. Onshape does not need to remain open for the account connection to be usable.
Best for starting work from inside Onshape. Keep the Onshape tab open while Adam works with the document.
## 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 an MCP client
Source: https://docs.adam.new/mcp/connect
Add the hosted Adam MCP server to Claude, Claude Code, Codex, Cursor, or another compatible client.
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.
Open **Settings** → **Connectors**, choose **Add custom connector**, and
enter `https://adam.new/mcp` as the server URL.
Adam supports automatic client registration. Do not add a manual OAuth
Client ID.
Start the connection, sign in to Adam, choose the workspace Claude may
access, and approve the permissions.
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.
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`.
Add Adam to your Cursor MCP configuration:
```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.
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 `.
## What you approve
During OAuth, Adam asks you to choose one workspace. The permission screen may
include access to models, projects, tasks, and files. Tools that are not covered
by the granted permissions do not appear to the client.
To remove access, open **Settings → Developer → Connected apps** in Adam and
revoke the client, or disconnect Adam in the client itself. Connect it again to
choose a different workspace or set of permissions.
Only connect clients you trust. An approved client can read or change data in
the selected workspace within the permissions shown by Adam.
## Troubleshooting
Adam supports automatic client registration, so a Client ID is not needed.
Remove the existing Adam connector, add it again with the exact server URL
`https://adam.new/mcp`, and retry the connection. Also update the MCP client
if it is not using a current version.
Disconnect Adam in the MCP client and reconnect it. Choose the intended
workspace on the Adam authorization screen.
Adam only advertises tools allowed by the connection's granted permissions.
Reconnect and approve the required project, task, model, or file access.
Task creation and messages start asynchronous work. Ask the client to call
`adam_get_task` until the task completes, fails, is cancelled, or requests
input.
Adam currently allows 120 requests per minute per credential. Wait for the
retry interval before continuing, and avoid polling a task continuously.
If the connection still fails, check [Adam status](https://status.adam.new) or
contact [hello@adam.new](mailto:hello@adam.new).
# Adam MCP
Source: https://docs.adam.new/mcp/overview
Connect an AI client to Adam and use tools for engineering projects, tasks, automations, messages, and files.
Adam MCP lets Claude, Codex, Cursor, and other MCP clients work in your Adam
workspace. Ask from the client you already use, and it can organize projects,
start engineering tasks, continue conversations, and find the resulting files.
```text theme={null}
https://adam.new/mcp
```
The Adam MCP server is in beta. Tools, schemas, behavior, and availability may
change at any time without prior notice, including breaking changes. Avoid
relying on it for production-critical workflows.
Add the hosted server, sign in with Adam, and choose a workspace.
See every available tool, its inputs, and the workflows they support.
## What you can do
* **Organize engineering work.** List, create, inspect, update, and—with your
confirmation—delete Adam projects and tasks.
* **Run Adam tasks.** Start a task with an available model, inspect its progress,
continue it with a message, or cancel it.
* **Handle questions and approvals.** Answer an interaction when a task needs
input, then let Adam continue the same task.
* **Use files.** Upload task attachments or shared project files, list generated
files, retrieve short-lived resource links for their contents, and—with your
confirmation—remove shared project files.
* **Inspect the workspace.** With permission, read the current subscription and
usage summary or see which integrations are available and connected.
* **Manage automations.** Create and edit scheduled or webhook-triggered work,
pause and resume it, or permanently delete it after confirmation.
## How task work runs
Adam tasks are asynchronous. An MCP call starts the work and returns promptly;
the AI client checks the task until it reaches a final state.
The client calls `adam_list_models` to use a model available to your
workspace.
The client calls `adam_create_task` and receives the new task ID and status.
The client calls `adam_get_task` until the task is `completed`, `failed`,
`cancelled`, or `awaiting_input`.
If the task is `awaiting_input`, the client reads the pending question or
approval and uses `adam_answer_interaction` to continue.
The client reads the final response, calls `adam_list_files`, and uses
`adam_get_file` when it needs the file contents.
## Try it after connecting
List my Adam projects. Create a project called Gearbox redesign if it does not
exist, list the available models, then start a task in that project to identify
the main design risks for a compact two-stage gearbox. Keep me updated until the
task finishes or needs my input.
## Access and permissions
OAuth is the recommended way to connect. Adam asks you to sign in, choose one
workspace, and approve the requested permissions. The connection acts as you
and can only use the tools allowed by those permissions. Removing you from the
workspace or revoking the connection ends that access.
File-aware clients can call `adam_upload_attachment` and pass the returned
upload ID to a task or message. The tool accepts base64 content, so your MCP
client must make the file bytes available to the model.
# MCP tools and workflows
Source: https://docs.adam.new/mcp/tools
Use Adam MCP tools to manage projects, run asynchronous tasks, answer interactions, and retrieve files.
Adam exposes focused tools for projects, tasks, conversations, and files. Your
client only sees tools allowed by the permissions granted during authentication.
## Context and models
| Tool | What it does | Main input | Permission |
| ------------------ | ----------------------------------------------------------------------------------- | ---------- | ---------------- |
| `adam_get_context` | Returns the connected user, workspace, credential type, and granted permissions. | None | Always available |
| `adam_list_models` | Lists model slugs available to the workspace. Use it before selecting a task model. | None | Always available |
## Billing and integrations
| Tool | What it does | Main input | Permission |
| -------------------------- | ------------------------------------------------------------------------------------------------------------------------- | ----------------- | ------------------- |
| `adam_get_billing_summary` | Returns the workspace subscription, effective plan, and high-level usage summary without payment details or internal IDs. | None | `billing:read` |
| `adam_list_integrations` | Lists available integrations and shows which are connected for the authenticated user. | None | `integrations:read` |
| `adam_get_integration` | Gets one integration and its connection status by stable slug. | `integrationSlug` | `integrations:read` |
## Automations
| Tool | What it does | Main input | Permission |
| ------------------------ | --------------------------------------------------------------------------- | ---------------------------------------------------------------- | ------------------- |
| `adam_list_automations` | Lists automations visible to the authenticated user. | None | `automations:read` |
| `adam_get_automation` | Gets one automation, its trigger, schedule, status, and latest run summary. | `automationId` | `automations:read` |
| `adam_create_automation` | Creates a recurring, one-time, or webhook-triggered automation. | Name, prompt, trigger-specific fields; optional `idempotencyKey` | `automations:write` |
| `adam_update_automation` | Edits an automation's name, prompt, effort, schedule, or visibility. | `automationId` and at least one field to change | `automations:write` |
| `adam_pause_automation` | Pauses future fires without deleting the automation. | `automationId` | `automations:write` |
| `adam_resume_automation` | Resumes and re-arms a paused automation. | `automationId` | `automations:write` |
| `adam_delete_automation` | Permanently deletes an automation after confirmation. | `automationId` and `confirm: true` | `automations:write` |
## Projects
| Tool | What it does | Main input | Permission |
| --------------------- | --------------------------------------------------------------------------- | --------------------------------------------------------------------------- | ---------------- |
| `adam_list_projects` | Lists projects in cursor-paginated pages. | Optional `limit` and `cursor` | `projects:read` |
| `adam_get_project` | Gets one project. | `projectId` | `projects:read` |
| `adam_create_project` | Creates a project. | `name`; optional description, visibility, memory scope, and idempotency key | `projects:write` |
| `adam_update_project` | Changes a project's name, description, visibility, or memory scope. | `projectId` and at least one field to change | `projects:write` |
| `adam_delete_project` | Permanently deletes an owned project. Its tasks and files become ungrouped. | `projectId` and `confirm: true` after user confirmation | `projects:write` |
## Tasks and conversations
| Tool | What it does | Main input | Permission |
| ------------------------- | ---------------------------------------------------------------------------------------- | ------------------------------------------------------------------------------------------- | --------------------------------------------- |
| `adam_list_tasks` | Lists cursor-paginated tasks, optionally filtered by project or status. | Optional `projectId`, `status`, `limit`, and `cursor` | `tasks:read` |
| `adam_get_task` | Gets a task, its messages, status, and pending interaction. | `taskId` | `tasks:read` |
| `adam_list_task_messages` | Lists structured message parts, including file references, tool calls, and tool results. | `taskId`; optional `limit` and `cursor` | `tasks:read` |
| `adam_create_task` | Creates and asynchronously starts a task. | `prompt`, `model`, and `idempotencyKey`; optional title, project, and attachment upload IDs | `tasks:write`; `files:write` with attachments |
| `adam_update_task` | Changes a task title or moves it into or out of a project. | `taskId` and a title or `projectId` | `tasks:write` |
| `adam_send_message` | Adds a user message and asynchronously continues a task. | `taskId`, `content`, and `idempotencyKey`; optional model and attachment upload IDs | `tasks:write`; `files:write` with attachments |
| `adam_answer_interaction` | Answers a pending question or approval. | `taskId`, `interactionId`, `response`, and `idempotencyKey` | `tasks:write` |
| `adam_cancel_task` | Cancels queued, running, or awaiting-input work. Repeated calls are safe. | `taskId` | `tasks:write` |
| `adam_delete_task` | Permanently deletes an owned task and its message history. | `taskId` and `confirm: true` after user confirmation | `tasks:write` |
The `model` object contains the model `slug`, the `fast` option, and an optional
`effort` of `low`, `medium`, `high`, or `xhigh`. Call
`adam_list_models` instead of guessing a model slug.
## Files
| Tool | What it does | Main input | Permission |
| -------------------------- | --------------------------------------------------------------------------------------------------------------------- | ------------------------------------------------------------------ | -------------------------------------------------------------- |
| `adam_list_files` | Lists a cursor-paginated page of files for exactly one task or project. | Either `taskId` or `projectId`; optional `limit` and `cursor` | `files:read` plus the matching task or project read permission |
| `adam_get_file` | Gets file metadata and a short-lived resource link for the current contents. | `fileId` | `files:read` |
| `adam_upload_attachment` | Uploads base64-encoded content and returns an upload ID for a task or message. | `name`, `mediaType`, and `contentBase64` | `files:write` |
| `adam_upload_project_file` | Uploads base64-encoded content as a durable shared project file. | `projectId`, `name`, `mediaType`, and `contentBase64` | `files:write` and `projects:write` |
| `adam_delete_project_file` | Removes a durable shared file from a project after confirmation. Task files and message attachments remain immutable. | `projectId`, `fileId`, and `confirm: true` after user confirmation | `files:write` and `projects:write` |
Use `adam_upload_attachment`, then pass the returned upload ID in the
`attachments` array of `adam_create_task` or `adam_send_message`. Upload IDs
expire after 24 hours. For durable shared inputs, use
`adam_upload_project_file` instead. Use `adam_delete_project_file` only after
the user confirms which shared project file to remove.
## Run a task reliably
Use `adam_get_context` when the client needs to confirm the connected user,
workspace, or permissions.
Use the list tools to find project IDs and model slugs. Adam validates project and
task IDs as UUIDs.
Pass a new UUID as `idempotencyKey` to `adam_create_task`. Reuse that key
only when retrying the exact same operation.
Call `adam_get_task` until the status is `completed`, `failed`, `cancelled`,
or `awaiting_input`. Do not start a duplicate task while the first one runs.
Answer a pending interaction with `adam_answer_interaction`. After
completion, use `adam_list_files` to find the resulting files and
`adam_get_file` to retrieve a resource link.
## Example requests
Find my Adam tasks that are waiting for input. Show me each question or approval
request before answering anything. After I respond, continue the selected task
and monitor it until it reaches another decision point or finishes.
List the tasks in my Gearbox redesign project. Summarize the completed tasks,
identify any failed or cancelled work, and list the output files with their
download links.
Find the Adam task about the enclosure drawing, rename it to Enclosure drawing
review, move it into the Enclosure project, and send a follow-up asking Adam to
check the design for injection-molding risks. Monitor it until it finishes or
needs my input.
# Quickstart
Source: https://docs.adam.new/quickstart
Complete your first useful task in Adam.
You can start using Adam immediately. You do not need to connect another tool first.
## Before you begin
Sign in at [adam.new](https://adam.new). If you want Adam to review a file, have it ready to upload.
![Adam New Task composer with an attachment button and example task suggestions]()
Select **New Task** in the sidebar.
Attach a file, drag it into the message box, or paste an image. Skip this step if your question does not need a file.
Tell Adam the outcome you want. Mention anything it should preserve, check, or avoid changing.
Adam shows its progress in the conversation. If it needs more information or your approval, answer in the task.
Read the response and open any files Adam creates. Reply in the same task to ask questions or refine the result.
## Write a useful first request
Say what Adam should review, what you want back, and anything it must not change.
Review the attached engineering drawing. Summarize what the part does, list its critical dimensions and tolerances, and flag anything that looks missing or ambiguous. Do not change the file.
Explain the main design considerations for a snap-fit enclosure that will be injection molded in ABS. Organize the answer into geometry, tolerances, material behavior, and common failure modes.
Keep replying in the same task when Adam needs to remember the earlier conversation or files.
## Connect a CAD tool when you need it
To work directly with a CAD document, follow the setup guide for [Onshape](/integrations/onshape), [Autodesk Fusion](/integrations/fusion), or a [supported desktop application](/integrations/desktop-connector). You can do this at any time from **Integrations**.
# 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 the Adam add-in from [fusion.adam.new/install](https://fusion.adam.new/install), 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.
## 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.
## Why is a model or reasoning option unavailable?
Some model and reasoning choices require a particular plan or enough remaining usage. Open **Settings** → **Billing** to check your plan and usage.
## 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 weekly included usage refreshes Monday at midnight UTC. After a paid member's weekly allowance and the workspace's add-on funds are depleted, they can continue with Lite on their daily allowance. Current amounts and add-on funds appear in **Settings** → **Billing**. See [Billing and usage](/admin/billing#after-weekly-usage-runs-out).
## Can I share an Adam result publicly?
Yes. A task can be published as a read-only plain or password-protected link. 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, rerun the installer from [fusion.adam.new/install](https://fusion.adam.new/install), then restart Fusion.
## A Desktop Connector application is offline
1. Open the Desktop Connector on the computer running the target application.
2. Start the application and its Adam plug-in.
3. Confirm the device still appears in the integration detail.
4. If necessary, generate a fresh expiring pairing code and pair again.
SolidWorks support requires Windows. Adam currently supports Revit 2027 through Autodesk's Public MCP Server Tech Preview.
## 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 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** | Light, dark, or system appearance on the current device. |
| **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. |
| **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 and other supported desktop applications](/integrations/desktop-connector) use the Adam Desktop Connector.
* [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.
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.