> ## Documentation Index
> Fetch the complete documentation index at: https://agenticadvertisingorg-snap-format-preview-links.mintlify.site/llms.txt
> Use this file to discover all available pages before exploring further.

# Implementing Creative Agents

> How to build an AdCP creative agent that defines formats, validates manifests, generates previews, and hosts a creative library.

> **Canonical formats in 3.1**: in the canonical-formats path, creative agents declare what they can produce via `creative.supported_formats` on `get_adcp_capabilities` (replacing the v1 `list_creative_formats` overload for creative agents). Each entry uses the same `ProductFormatDeclaration` shape as a product's inline `format_options[i]`. See [canonical-formats](/docs/creative/canonical-formats).

This guide explains how to implement a creative agent that defines and manages creative formats.

## What is a creative agent?

A creative agent is a service that:

* **Defines formats** - Specifies what assets are required and how they should be structured
* **Validates manifests** - Ensures creative manifests meet format requirements
* **Generates previews** - Shows how creatives will render
* **Builds creatives** (optional) - Generates manifests from natural language briefs or retrieves them from a library
* **Hosts a creative library** (optional) - Lets buyers browse and filter existing creatives

An ad server (CM360, Flashtalking), creative management platform, creative agency, publisher, or sales agent can implement a creative agent. Sales agents that implement the Creative Protocol alongside the Media Buy Protocol serve both roles from a single endpoint — see [Creative capabilities on sales agents](/docs/creative/sales-agent-creative-capabilities).

## Three interaction models

Creative agents fall into three distinct categories based on how assets arrive and what the output is. Identifying which model your agent follows determines which tasks to implement and how buyers will interact with you.

### Stateless: template and transformation agents

**Examples:** Celtra, format conversion services, rich media template platforms

The buyer passes all assets inline with each call. Your agent applies a template or transformation and returns the result. There is no persistent creative library — every call is self-contained.

| Task                    | Role                                                      |
| ----------------------- | --------------------------------------------------------- |
| `list_creative_formats` | Discover available templates and their asset requirements |
| `preview_creative`      | Render a template with provided assets                    |
| `build_creative`        | Transform input assets into a serving tag                 |

**Capabilities:** `supports_transformation: true`

The buyer's workflow: discover your formats → preview with real assets → request built creatives for trafficking.

### Stateful (pre-loaded): ad servers

**Examples:** Innovid, Flashtalking, CM360

Creatives already exist in your system, loaded through your platform's UI or API. Buyers connect to browse your library and request serving tags for their media buys. The buyer never pushes assets to you — they reference creatives that are already there.

| Task                    | Role                                                              |
| ----------------------- | ----------------------------------------------------------------- |
| `list_creatives`        | Browse existing creatives in the library                          |
| `build_creative`        | Generate a serving tag for a specific `creative_id` and media buy |
| `preview_creative`      | Preview an existing creative                                      |
| `get_creative_delivery` | Report variant-level delivery metrics                             |

**Capabilities:** `has_creative_library: true`

The buyer's workflow: browse your creative library → request tags per media buy → track delivery.

### Stateful (push): sales agents with creative

**Examples:** Publisher platforms, retail media networks, native ad platforms

Buyers push creative assets or catalog items to your platform. You validate, store, and render them in your environment. This is where catalog-driven creative gets interesting — buyers might push product feeds, flight listings, or hotel inventory that you render as native ads.

| Task                    | Role                                                    |
| ----------------------- | ------------------------------------------------------- |
| `list_creative_formats` | Discover what formats you accept                        |
| `sync_creatives`        | Accept pushed assets or catalog items                   |
| `preview_creative`      | Preview pushed creatives in your platform's environment |
| `get_creative_delivery` | Report delivery metrics                                 |

**Capabilities:** `has_creative_library: true`

The buyer's workflow: discover your accepted formats → push assets → preview in your environment.

### Choosing your model

The key question is: **where do the assets come from?**

* If the buyer sends assets with every call → **stateless (template/transformer)**
* If creatives already exist in your system → **stateful (ad server)**
* If the buyer pushes assets to you for hosting → **stateful (sales agent)**

Some agents combine models. A creative management platform might be both a template engine (stateless transformation) and a library host (stateful). Declare the appropriate capability flags in `get_adcp_capabilities` so buyers can determine the right interaction model.

### Pricing and statefulness

A creative agent that charges for its services needs an account relationship. Adding pricing requires:

1. **Implement the [Accounts Protocol](/docs/accounts/overview)** — buyers establish accounts with rate cards
2. **Expose `pricing_options` on discovery** — on `list_creative_formats` (transformation/generation agents) or `list_creatives` (ad servers/library agents)
3. **Return pricing in `build_creative` responses** — `pricing_option_id`, `vendor_cost`, `currency`, and `consumption`
4. **Accept `report_usage`** — orchestrators report what was served so you can track revenue

Free transformation agents remain stateless and unchanged. No account, no pricing required.

#### Pricing discovery by agent type

| Agent type                                       | Discovery surface       | Why                                                                            |
| ------------------------------------------------ | ----------------------- | ------------------------------------------------------------------------------ |
| **Transformation** (Celtra)                      | `list_creative_formats` | Buyers see pricing per format before any creative exists                       |
| **Generation** (AI platforms)                    | `list_creative_formats` | Same — pricing is on the capability, not a pre-existing creative               |
| **Ad server** (Innovid, CM360)                   | `list_creatives`        | Buyers see pricing on specific creatives in the library                        |
| **Both** (Celtra, creative management platforms) | Both surfaces           | Library pricing on `list_creatives`, format pricing on `list_creative_formats` |

Transformation and generation agents do not need to implement `list_creatives` for pricing — `list_creative_formats` is the natural surface since the format is the product.

#### Pricing walkthrough

Here is the full round-trip for a transformation agent charging per format adapted.

**Step 1: Buyer discovers pricing via `list_creative_formats`**

The buyer calls `list_creative_formats` with `include_pricing: true` and their `account`. Your agent looks up the account's rate card and returns `pricing_options` on each format:

```json theme={null}
{
  "formats": [
    {
      "format_id": { "agent_url": "https://creative.example.com", "id": "display_300x250" },
      "name": "Display 300x250",
      "pricing_options": [
        {
          "pricing_option_id": "po_standard_per_format",
          "model": "per_unit",
          "unit": "format",
          "unit_price": 2.00,
          "currency": "USD"
        },
        {
          "pricing_option_id": "po_volume_per_format",
          "model": "per_unit",
          "unit": "format",
          "unit_price": 1.25,
          "currency": "USD"
        }
      ]
    }
  ]
}
```

Multiple options are common — here the buyer sees a standard rate and a volume rate. For ad servers, the same `pricing_options` pattern appears on `list_creatives` instead.

**Step 2: Buyer builds a creative**

The buyer calls `build_creative` with their `account`. Your agent performs the work, selects the applicable pricing option server-side (based on the account's commitment level, the work performed, etc.), and returns the cost:

```json theme={null}
{
  "creative_manifest": {
    "creative_id": "cr_hero_banner",
    "format_id": { "agent_url": "https://creative.example.com", "id": "display_728x90" },
    "assets": { "..." : "..." }
  },
  "pricing_option_id": "po_standard_per_format",
  "vendor_cost": 2.00,
  "currency": "USD",
  "consumption": {
    "renders": 1
  }
}
```

The `pricing_option_id` tells the buyer which rate was applied. The `consumption` object lets the buyer verify: 1 render × $2.00/format = $2.00 `vendor_cost`.

For **CPM-priced creatives** (ad servers), `vendor_cost` is 0 at build time — cost accrues when impressions are served:

```json theme={null}
{
  "creative_manifest": { "..." : "..." },
  "pricing_option_id": "po_video_cpm",
  "vendor_cost": 0,
  "currency": "USD"
}
```

**Step 3: Buyer reports usage**

After the campaign delivers, the buyer reports usage via [`report_usage`](/docs/accounts/tasks/report_usage). This example shows CPM reporting, where cost accrued during delivery rather than at build time. The `pricing_option_id` and `creative_id` flow through for reconciliation:

```json theme={null}
{
  "reporting_period": { "start": "2026-03-01T00:00:00Z", "end": "2026-03-31T23:59:59Z" },
  "usage": [
    {
      "account": { "account_id": "acct_acme_creative" },
      "creative_id": "cr_hero_banner",
      "pricing_option_id": "po_video_cpm",
      "impressions": 2400000,
      "vendor_cost": 1200.00,
      "currency": "USD"
    }
  ]
}
```

Your agent validates that `pricing_option_id` matches the account's rate card and accepts the record.

#### Who selects the pricing option?

The **vendor agent** selects the pricing option, not the buyer. The buyer passes `account` on `build_creative` — the agent determines which pricing option applies based on the account's rate card, the work performed, and any commitment tiers. The response tells the buyer what was applied.

The buyer does not pass `pricing_option_id` on the `build_creative` request. They see the options on `list_creatives`, and they receive the applied option on the `build_creative` response.

#### Consumption fields by agent type

| Agent type      | Typical `consumption` fields | Notes                                      |
| --------------- | ---------------------------- | ------------------------------------------ |
| Transformation  | `renders`                    | Number of format adaptations performed     |
| AI generation   | `tokens`, `images_generated` | LLM tokens consumed, images produced       |
| Ad server (CPM) | Omitted                      | Cost accrues at serve time, not build time |
| Multi-variant   | `renders`                    | Number of variants rendered                |

The `consumption` object is informational — it lets the buyer verify that `vendor_cost` is consistent with the rate card. `vendor_cost` is the billing source of truth.

## Core requirements

### 1. Format ID namespacing

Every format you define must use structured format IDs with your agent URL to prevent conflicts:

```json theme={null}
{
  "format_id": {
    "agent_url": "https://youragency.com",
    "id": "video_story_15s"
  }
}
```

**Rules:**

* `agent_url` must match your agent's URL
* `id` should be descriptive and unique within your namespace
* Use lowercase with underscores for consistency

### 2. Format validation

When formats reference your agent\_url, you are the authority for:

* Format specifications
* Asset validation rules
* Technical requirements
* Preview generation

**Format definition example:**

```json theme={null}
{
  "format_id": {
    "agent_url": "https://youragency.com",
    "id": "story_sequence_5frame"
  },
  "name": "5-Frame Story Sequence",
  "type": "display",
  "min_frames": 5,
  "max_frames": 5,
  "frame_schema": {
    "assets": [
      {
        "asset_type": "image",
        "asset_role": "frame_image",
        "required": true,
        "requirements": {
          "width": 1080,
          "height": 1920,
          "file_types": ["jpg", "png", "webp"],
          "max_file_size_kb": 500
        }
      },
      {
        "asset_type": "text",
        "asset_role": "caption",
        "required": false,
        "requirements": {
          "max_length": 100
        }
      }
    ]
  },
  "global_assets": [
    {
      "asset_type": "image",
      "asset_role": "brand_logo",
      "required": true,
      "requirements": {
        "width": 200,
        "height": 200,
        "transparency_required": true
      }
    }
  ]
}
```

## Required tasks

Creative agents must implement these two tasks:

### list\_creative\_formats

Return all formats your agent defines. This is how buyers discover what creative formats you support.

**Key responsibilities:**

* Return complete format definitions with all `assets` (both required and optional)
* Include your `agent_url` in each format
* Use proper namespacing for `format_id` values

See [list\_creative\_formats task reference](/docs/creative/task-reference/list_creative_formats) for complete API specification.

### preview\_creative

Generate a visual preview showing how a creative manifest will render in your format.

**Key responsibilities:**

* Validate manifest against format requirements
* Return validation errors if manifest is invalid
* Generate visual representation (URL, image, or HTML)
* Preview should be accessible for at least 24 hours

See [preview\_creative task reference](/docs/creative/task-reference/preview_creative) for complete API specification.

## Optional tasks

### build\_creative

Generate a creative manifest from a natural language brief, transform an existing manifest to a new format, or retrieve a library creative as a delivery-ready manifest.

**Key responsibilities:**

* Parse natural language brief or resolve a `creative_id` from your library
* Generate or source appropriate assets
* Return valid manifest for the target format
* Substitute `macro_values` into serving tags when provided
* Optionally return preview URL

See [build\_creative task reference](/docs/creative/task-reference/build_creative) for complete API specification.

### list\_creatives

Browse and filter creatives in your library. Implement this if your platform hosts a creative library that buyers need to query.

**Key responsibilities:**

* Return creatives accessible to the authenticated account
* Support filtering by format, status, tags, and date range
* Support pagination for large libraries
* Optionally include dynamic creative optimization (DCO) variable definitions per creative

See [list\_creatives task reference](/docs/creative/task-reference/list_creatives) for complete API specification.

### sync\_creatives

Accept creative asset uploads into your library. Implement this if your platform allows buyers to push assets.

**Key responsibilities:**

* Validate creatives against format specifications
* Return per-creative results with platform-assigned IDs
* Support upsert semantics (create or update by `creative_id`)
* Optionally support bulk package assignments (for agents that also manage media buys)
* Optionally support async approval workflows for brand safety review

See [sync\_creatives task reference](/docs/creative/task-reference/sync_creatives) for complete API specification.

## Validation best practices

### Manifest validation

When validating manifests:

1. **Check format\_id** - Ensure it references your agent
2. **Validate required assets** - All required assets must be present
3. **Check asset types** - Assets must match specified types
4. **Validate requirements** - Dimensions, file types, sizes, etc.
5. **URL accessibility** - Verify asset URLs are accessible (optional but recommended)

**Example validation errors:**

```json theme={null}
{
  "status": "error",
  "error": "validation_failed",
  "validation_errors": [
    {
      "asset_id": "frame_1_image",
      "error": "missing_required_asset",
      "message": "Required asset 'frame_1_image' is missing"
    },
    {
      "asset_id": "brand_logo",
      "error": "invalid_dimensions",
      "message": "Logo must be 200x200px, got 150x150px"
    }
  ]
}
```

### Disclosure requirements

When a creative brief includes `compliance.required_disclosures`, creative agents must ensure each disclosure appears in the generated creative. The workflow:

1. **Check format support** — Compare each `required_disclosures[].position` against the format's `supported_disclosure_positions` or `disclosure_capabilities`. If a required position is not supported by the format, return a validation error rather than silently dropping it. When `disclosure_capabilities` is present, use it for persistence-aware matching — verify that the format supports both the required position and the required persistence mode.

2. **Respect persistence** — When the brief specifies `persistence` on a required disclosure, the creative agent must satisfy it using a position that supports that persistence mode in the format's `disclosure_capabilities`. For example, if a brief requires `"continuous"` persistence for an EU AI Act disclosure, the format must declare that position with `"continuous"` in its `disclosure_capabilities`. When the brief omits `persistence`, use the most restrictive persistence mode the format supports for that position.

3. **Render disclosures** — For positions your format supports:
   * `footer`, `overlay`, `end_card`, `prominent`: Render the disclosure `text` into the creative at the specified position
   * `audio`, `pre_roll`: Include disclosure as spoken audio. Respect `min_duration_ms` if specified.
   * `subtitle`: Include as a text track within the video creative
   * `companion`: Deliver in the companion ad unit alongside the primary creative

4. **Respect jurisdiction scoping** — A disclosure with `jurisdictions: ["US"]` is legally required only in the US. Creative agents that produce a single creative per brief should include all jurisdictional disclosures. If your agent can produce jurisdiction-specific variants, filter disclosures by their `jurisdictions` field.

5. **Propagate into provenance** — When the brief specifies `persistence` and `position` on a required disclosure, propagate these into `provenance.disclosure.jurisdictions[].render_guidance` on the creative manifest. The brief is a creation-time document; at serve time, the publisher has the creative and its provenance, not the brief. If the creative agent does not propagate persistence into provenance render guidance, the publisher has no way to know what persistence the regulation requires.

6. **Preserve through regeneration** — When regenerating or resizing a creative, carry forward all disclosures from the `BriefAsset` attached to the manifest. A `BriefAsset` is a `brief`-typed asset in the format's `assets` array that carries the creative brief through the manifest, ensuring disclosures survive format adaptation.

**Example:** A brief requires `"KI-generiert"` disclosure at `overlay` position with `persistence: "continuous"` for `eu_ai_act_article_50`. Your format declares `disclosure_capabilities: [{ "position": "overlay", "persistence": ["continuous", "initial"] }]`. The format supports continuous overlay, so the creative agent renders the disclosure as a persistent overlay visible throughout the content. The agent also propagates `render_guidance: { "persistence": "continuous", "positions": ["overlay"] }` into the EU jurisdiction entry in `provenance.disclosure.jurisdictions[]`.

### Format evolution

When updating format definitions:

* **Additive changes** (new optional assets with `required: false` in `assets`) are safe
* **Breaking changes** (removing assets, changing requirements) require new format\_id
* Consider versioning: `youragency.com:format_name_v2`
* Maintain backward compatibility when possible

## Deployment checklist

Before launching your creative agent:

* [ ] MCP and/or A2A endpoints are accessible
* [ ] All format\_ids use proper namespacing (`domain:id`)
* [ ] Domain in format\_id matches your `agent_url` domain
* [ ] `list_creative_formats` returns all your formats
* [ ] `preview_creative` validates manifests and generates previews
* [ ] Format definitions include complete asset requirements
* [ ] Documentation available for your custom formats

## Integration patterns

### Pattern 1: creative agency

You're a creative agency building custom formats for brands:

```json theme={null}
{
  "format_id": {
    "agent_url": "https://brandstudio.com",
    "id": "hero_video_package"
  },
  "name": "Hero Video Package",
  "type": "video",
  "description": "Premium video creative with multiple aspect ratios",
  "assets": [
    {"asset_role": "hero_video_16x9", ...},
    {"asset_role": "hero_video_9x16", ...},
    {"asset_role": "hero_video_1x1", ...}
  ]
}
```

### Pattern 2: platform-specific formats

You're a platform defining specialized formats:

```json theme={null}
{
  "format_id": {
    "agent_url": "https://platform.com",
    "id": "interactive_quiz"
  },
  "name": "Interactive Quiz Ad",
  "type": "rich_media",
  "description": "Engagement-driven quiz format",
  "assets": [
    {"asset_role": "question_1", "asset_type": "text", ...},
    {"asset_role": "answer_1a", "asset_type": "text", ...},
    // ... quiz structure
  ]
}
```

### Pattern 3: format extension service

You provide enhanced versions of standard formats:

```json theme={null}
{
  "format_id": {
    "agent_url": "https://enhanced.com",
    "id": "video_30s_optimized"
  },
  "name": "Optimized 30s Video",
  "type": "video",
  "extends": "creative.adcontextprotocol.org:video_30s",
  "description": "Standard 30s video with automatic optimization",
  "assets": [
    // Same requirements as standard format
  ],
  "enhancements": {
    "auto_transcode": true,
    "quality_optimization": true,
    "format_variants": ["mp4", "webm", "hls"]
  }
}
```

### Pattern 4: feed-native/social format agent

You host ad formats that render as native content within your platform's feed:

```json theme={null}
{
  "format_id": {
    "agent_url": "https://ads.socialplatform.com",
    "id": "promoted_post"
  },
  "name": "Promoted post",
  "type": "native",
  "description": "Sponsored content that appears in the feed alongside organic posts. Renders with platform chrome (user avatar, engagement buttons, community badge).",
  "assets": [
    {
      "item_type": "individual",
      "asset_id": "headline",
      "asset_type": "text",
      "required": true,
      "requirements": { "max_length": 300 }
    },
    {
      "item_type": "individual",
      "asset_id": "body",
      "asset_type": "text",
      "required": false,
      "requirements": { "max_length": 1000 }
    },
    {
      "item_type": "individual",
      "asset_id": "image",
      "asset_type": "image",
      "required": false,
      "requirements": { "max_width": 1200, "max_height": 628, "accepted_types": ["image/jpeg", "image/png"] }
    },
    {
      "item_type": "individual",
      "asset_id": "click_url",
      "asset_type": "url",
      "required": true,
      "requirements": {}
    }
  ]
}
```

Platform-specific rendering (dark mode, community context, engagement UI) is handled by the agent at preview and serve time — the format definition specifies only the buyer-provided assets. The agent wraps these assets in the platform's native chrome.

When a buyer calls `preview_creative` for a feed-native format, the preview renders the buyer's assets inside the platform's UI — avatar, engagement buttons, community badge, and all:

```json theme={null}
{
  "request_type": "single",
  "creative_manifest": {
    "format_id": {
      "agent_url": "https://ads.socialplatform.com",
      "id": "promoted_post"
    },
    "assets": {
      "headline": { "content": "Introducing our new trail running collection" },
      "body": { "content": "Built for the mountains. Tested on every terrain." },
      "image": { "url": "https://cdn.acme-example.com/trail-hero.jpg", "width": 1200, "height": 628 },
      "click_url": { "url": "https://acme-example.com/trail-running" }
    }
  },
  "inputs": [
    { "name": "Running community", "context_description": "Appears in r/trailrunning feed between user posts" },
    { "name": "General feed", "context_description": "Appears in home feed between mixed content" }
  ]
}
```

The preview response shows how the ad looks in each context — including community-specific chrome that the buyer cannot preview elsewhere. This is why platforms should implement `preview_creative` even for simple formats: the platform chrome is the differentiator.

## Platform mapping

If you're wrapping an existing ad server or creative management platform, this section shows how common platform concepts map to the creative protocol.

### Concept mapping

| Platform concept                           | AdCP equivalent                                                     | Notes                                                                                                                 |
| ------------------------------------------ | ------------------------------------------------------------------- | --------------------------------------------------------------------------------------------------------------------- |
| Advertiser / account                       | Account (via [accounts protocol](/docs/accounts/overview))          | Buyer establishes access before querying the library                                                                  |
| Creative concept / group / template folder | `concept_id` in `list_creatives`                                    | Groups related creatives across sizes/formats (Flashtalking concepts, Celtra campaign folders, CM360 creative groups) |
| Creative                                   | Creative item in `list_creatives` response                          |                                                                                                                       |
| Creative type + size                       | `format_id` (structured object with `agent_url`, `id`, dimensions)  | AdCP combines type and size into a single format reference                                                            |
| Template (Celtra's term)                   | Format (via `list_creative_formats`)                                | Celtra templates define structure and available properties; AdCP formats define structure and available assets        |
| Template object properties (Celtra)        | `variables` array                                                   | Named slots with types (text, color, image, video, number, boolean) — near-exact match                                |
| Active / archived / pending                | `status` field                                                      |                                                                                                                       |
| Ad tag / serving tag                       | Asset in a creative manifest (`html`, `javascript`, or `vast` type) | Tags are just assets — no special concept                                                                             |
| Placement / ad unit                        | Package within a media buy                                          | The buy context where a creative is assigned                                                                          |
| DCO variables / dynamic fields             | `variables` array (via `include_variables=true`)                    | Named slots with types and defaults                                                                                   |
| Data feed / targeting rules                | Not modeled                                                         | AdCP models the variable *slots*, not the optimization rules                                                          |
| CTV/OTT ad server (Innovid, Brightcove)    | Same as ad server, plus VAST/SSAI delivery model                    | VAST tags in `vast`-type assets; companion ads via multi-render formats                                               |

### Tag generation models

Ad servers differ in how they produce serving tags. The creative protocol's `build_creative` accommodates all common models through the combination of `creative_id`, `target_format_id`, and optional `media_buy_id`/`package_id`:

**Universal tags** (Celtra, Flashtalking) — A single tag that adapts to multiple environments (web, in-app). No placement context is needed — `build_creative(creative_id, target_format_id)` produces a tag that works wherever it's trafficked. Best for agency/programmatic use cases where the final destination is unpredictable, reducing trafficking errors.

**Single-placement tags** (Celtra, Flashtalking, CM360) — A tag scoped to one specific size and placement. The `target_format_id` specifies the exact dimensions (e.g., 300x250 web). For publisher template use cases where the destination is known, this is the most common choice.

**Multi-placement tags** (Celtra) — A tag covering multiple sizes within one environment. The `target_format_id` references a format whose `renders` array defines the supported sizes. Useful for publisher templates that need several sizes (e.g., 300x250 + 320x50 + 728x90 web) but want a single tag to traffic.

**Placement-level tags** (CM360) — The platform generates tags per placement, not per creative. The caller passes `media_buy_id` and optionally `package_id` to provide the trafficking context. A CM360 adapter uses the media buy context to produce a tag scoped to the target format.

The choice between these models is often a campaign context decision, not a platform constraint. The same creative agent may produce different tag types depending on the caller's needs:

| Use case                                  | Tag type         | `build_creative` parameters                                        |
| ----------------------------------------- | ---------------- | ------------------------------------------------------------------ |
| Agency/programmatic (unknown destination) | Universal        | `creative_id` + `target_format_id` (universal format)              |
| Publisher template (known placement)      | Single placement | `creative_id` + `target_format_id` (specific size)                 |
| Publisher template (multiple sizes)       | Multi-placement  | `creative_id` + `target_format_id` (multi-render format)           |
| Ad server with trafficking context        | Placement-level  | `creative_id` + `target_format_id` + `media_buy_id` + `package_id` |

In all cases the output is the same: a creative manifest with the serving code in an `html` or `javascript` asset.

### Variable models

Platforms represent dynamic content differently. The creative protocol's `variables` array accommodates the common patterns:

**Named variable slots** (Flashtalking) — Each creative has explicit variables with IDs, names, and types. Maps directly to `creative-variable.json`.

**Template object properties** (Celtra) — Templates define `templateObjects` with typed `properties` (text, color, image, video, percentage, hidden) scoped to specific components and size variants. A Celtra adapter flattens these into the `variables` array, using the template object label and property label to construct `variable_id` and `name`.

**Rule-based asset selection** (CM360) — Dynamic creatives use `dynamicAssetSelection` with targeting rules, fed by data feeds. This model is not variable-based — CM360 adapters would typically not populate the `variables` array, and `has_variables` filtering would not apply.

### Macro handling

Platforms use their own macro syntax internally. The `macro_values` parameter in `build_creative` lets the caller pass universal macro values (e.g., `CLICK_URL`) that the creative agent substitutes into the output tag using whatever syntax the platform expects.

| Universal macro | CM360 equivalent | Flashtalking equivalent |
| --------------- | ---------------- | ----------------------- |
| `CLICK_URL`     | `%c`             | `[clickTag]`            |
| `CACHEBUSTER`   | `%n`             | `[timestamp]`           |
| `TIMESTAMP`     | `%t`             | `[timestamp]`           |

The creative agent handles translation — callers always use universal macros.

### Re-submission after rejection

When `sync_creatives` or creative review results in a rejection, the fix-and-resubmit flow uses upsert semantics:

1. Check rejection reason via `list_creatives` (library `status: "rejected"`) or `get_media_buys` (package `approval_status: "rejected"` with `rejection_reason`)
2. Fix the creative (update assets, adjust copy, replace media)
3. Re-submit via `sync_creatives` with the same `creative_id` — the agent updates the existing creative and re-triggers review
4. Poll `list_creatives` until `status` transitions from `pending_review` to `approved` or `rejected`

Re-submission resets the review clock. The agent treats the updated creative as a new submission for review purposes.

### Which tasks to implement

The table below maps each interaction model to the tasks it should implement. See [Three interaction models](#three-interaction-models) above for detailed descriptions.

| Interaction model                                    | Required tasks                                                | Additional tasks                                 | Capabilities                    |
| ---------------------------------------------------- | ------------------------------------------------------------- | ------------------------------------------------ | ------------------------------- |
| Template/transformer (Celtra, format conversion)     | `list_creative_formats`, `preview_creative`, `build_creative` | —                                                | `supports_transformation: true` |
| Ad server (Innovid, Flashtalking, CM360)             | `list_creatives`, `build_creative`, `preview_creative`        | `list_creative_formats`, `get_creative_delivery` | `has_creative_library: true`    |
| Sales agent with creative (publishers, retail media) | `list_creative_formats`, `sync_creatives`, `preview_creative` | `get_creative_delivery`                          | `has_creative_library: true`    |
| Generative creative tool                             | `list_creative_formats`, `preview_creative`, `build_creative` | —                                                | `supports_generation: true`     |

Declare these capabilities in `get_adcp_capabilities` so buyer agents can determine the correct interaction model without trial and error. See [Interaction models](/docs/creative/specification#interaction-models) in the spec.

Platforms with a creative library should also implement the [accounts protocol](/docs/accounts/overview) so buyers can establish access before querying. This is the same accounts protocol used by sales agents for media buys.

## Related

* [Creative Formats](/docs/creative/formats) - Understanding format structure
* [Creative Manifests](/docs/creative/creative-manifests) - How manifests work
* [Asset Types](/docs/creative/asset-types) - Asset specifications
* [list\_creative\_formats task](/docs/creative/task-reference/list_creative_formats) - Format discovery API reference
* [list\_creatives task](/docs/creative/task-reference/list_creatives) - Creative library API reference
* [build\_creative task](/docs/creative/task-reference/build_creative) - Manifest generation API reference
* [preview\_creative task](/docs/creative/task-reference/preview_creative) - Preview rendering API reference