canonical: https://jentic.com/apis/adam.new/adam

# Adam New Adam API

The Adam API creates projects and runs AI engineering tasks, letting an agent start a task, continue it with messages, and retrieve the files it produces. External tasks go further: an agent creates one, discovers the harness tool schemas available to it, submits tool calls, and polls their durable outcomes, with idempotency keys so an identical call is not run twice. It also lists available models and connected integrations, uploads attachments and project files, and drives recurring work through automations. Access is granted by a personal bearer token or an OAuth2 token, with scopes that match each operation to the authority it needs.

## For AI agents

Create projects, start and continue AI engineering tasks, run harness tools in external tasks, and download the files tasks produce. Authenticates with a personal bearer token or an OAuth2 adamId token.

## Scope

Does not handle model training, dataset labeling, or GPU provisioning. Use for running and managing AI engineering tasks and their files only.

## Capabilities

- Create projects and start AI engineering tasks, then continue them by sending messages
- Create externally controlled tasks and run harness tools through their discovered tool schemas
- List available models and connected integrations before starting a task
- Upload attachments and project files, then retrieve a task's generated files and their content
- Create, pause, resume, and delete automations that drive recurring task work
- Inspect a task's messages, interactions, and tool-call outcomes to track progress

## Use cases

### Agent-Orchestrated Engineering Tasks via Jentic

An AI agent can hand engineering work to Adam and supervise it rather than doing the work itself. Through Jentic the agent creates a project, starts a task from a prompt, continues it with messages as requirements change, and downloads the resulting files, checking task state and interactions between steps.

Example prompt: Create a project, start a task describing the change to make, send a follow-up message with a correction, then list and download the task's files once it reports done

### External Harness Tool Execution

External tasks let a caller drive Adam's harness tools directly without an Adam agent loop. The agent creates an external task, discovers the tool schemas it exposes, submits a tool call with an idempotency key, and polls the call until its outcome is durable, reusing the same key for an identical retry so the work never runs twice.

Example prompt: Create an external task, read its available tool schemas, submit a tool call with an idempotency key, and poll the call id until the outcome is final

### Scheduled Automations

Recurring engineering work runs through automations that an agent creates once and controls over time. The agent lists, creates, updates, pauses, and resumes automations, so routine tasks run on their own cadence while the agent only steps in to adjust or inspect them.

Example prompt: Create an automation that runs a maintenance task, then pause it and resume it to confirm the schedule control works

## Key endpoints

| Method | Path | Description |
| --- | --- | --- |
| POST | `/v1/tasks` | Create and start a task |
| GET | `/v1/tasks` | List tasks |
| POST | `/v1/projects` | Create a project |
| POST | `/v1/tasks/{taskId}/messages` | Send a message to a task |
| POST | `/v1/tasks/external` | Create an externally controlled task |
| POST | `/v1/tasks/{taskId}/tool-calls` | Run a tool in an external task |
| GET | `/v1/models` | List available models |

## Key resources

- **Projects** — Create, read, update, and delete projects and manage their files.
- **Tasks** — Start tasks, continue them with messages, answer interactions, cancel, and list files; external tasks add tool discovery and tool calls.
- **Automations** — List, create, update, pause, resume, and delete recurring task automations.
- **Models and integrations** — List the models and connected integrations available to tasks.

## AI readiness

This API is usable in Jentic One now. Its AI-readiness score against Jentic's framework shows where it stands today and where improvements would make it even easier for agents to use.

- **Score:** 66 / 100
- **Maturity:** AI-Aware
- **Dimensions:**
  - Foundational Compliance: 99 / 100
  - Developer Experience & Jentic Compatibility: 62 / 100
  - AI-Readiness & Agent Experience: 46 / 100
  - Agent Usability: 94 / 100
  - Security: 75 / 100
  - AI Discoverability: 62 / 100
- **View full report:** https://jentic.com/apis/adam.new/adam/scorecard
- **How the score is calculated:** https://docs.jentic.com/reference/api-readiness-framework/overview/
- **More about the dimensions:** https://docs.jentic.com/reference/api-readiness-framework/specification/#dimensional-model-overview

### Score it yourself

Every API in the directory is allowlisted, so you can re-score it with no key required.

- **Score your own API:** https://jentic.com/scorecard.md
- **Scoring CLI agent skill:** https://github.com/jentic/jentic-api-scorecard/blob/main/skills/jentic-api-scorecard/SKILL.md

```sh
npx @jentic/api-scorecard-cli score <openapi-url>
```

## Why Jentic

- **Setup:** Wiring Adam by hand means choosing between a personal bearer token and the OAuth2 adamId flow, matching scopes like task read, task write, and tool-execute authority to each call, and polling tool-call outcomes yourself. Through Jentic you install once, import Adam from the API Directory, store the credential once, and your agent starts and continues tasks.
- **Permission scoping:** Adam puts the task id in the URL path (`/v1/tasks/{taskId}`), so a rule can pin your agent to one task and the operations you pick, such as sending messages and reading files. You choose which operations it may call, so deleting projects or minting external tool calls stays out unless you add it.
- **Credential handling:** Your Adam token is stored once, encrypted, by your own Jentic One instance and injected at execution time. It never enters the agent's prompt, logs, or context.
- **Discovery method:** Agents search Jentic by intent such as 'start an AI coding task' or 'run a tool in a task', and Jentic returns the matching Adam operation with its input schema so the agent calls the right endpoint directly.

## Related APIs

- **OpenAI** — OpenAI exposes models and an assistants surface you orchestrate yourself; Adam runs managed engineering tasks end to end.
- **Anthropic Messages** — Anthropic's Messages API is a model endpoint you drive turn by turn; Adam wraps engineering work as projects and tasks.
- **Replicate** — Replicate runs individual hosted models; Adam can call model services inside a broader engineering task.

## FAQ

### What authentication does the Adam API use?

The Adam API accepts two credentials per its OpenAPI spec: a personal API key sent as a bearer token, and an OAuth2 access token from the adamId authorization-code flow. Operations require scopes such as task read, task write, and tool-execute authority, and reading an external tool call's results needs both task read and tool-execute because outputs can contain workspace and connected-account data. Through Jentic the credential is stored encrypted on your own instance and injected at call time.

### Is there an Adam MCP server?

You don't need an MCP server to give your agent Adam. Jentic connects it directly from the API Directory: import Adam, store your bearer or OAuth2 credential once, and your agent starts tasks, runs tools, and downloads files straight away. Operations are discovered on demand, so no extra server's tool definitions sit in your agent's context.

### Can I limit what my agent is allowed to do with the Adam API?

Yes. Because the task id travels in the URL path, you can write a rule that allows only sending messages and reading files on one task, so the agent can drive that task and nothing else. Deleting projects or minting external tool calls stays out of the rule unless you add it, which pairs with Adam's own scope model where tool-execute authority is a separate grant.

### Can I run harness tools in an external task with the Adam API?

Yes. Create an external task, discover its tool schemas, submit a tool call, and poll the call id for a durable outcome. Calls run tools without an Adam agent loop, individual tools may use compute or connected accounts, and reusing the same idempotency key replays an identical call rather than running it twice.

### What are the rate limits for the Adam API?

The Adam OpenAPI spec does not publish numeric request rate limits. For long-running work it recommends idempotency keys so a retried call does not execute twice and polling tool-call outcomes rather than resubmitting. Check the Adam documentation at https://adam.new for any current limits.

### How do I start an engineering task with the Adam API through Jentic?

Search the Jentic API Directory for an intent like 'start an AI coding task', import Adam, and store your credential once. Your agent then creates a project, starts the task, and continues it with messages through Jentic. To run it on your own infrastructure, install Jentic One from its GitHub repo.