Skip to main content
This page explains what Apostra requires from a Sales Agent before we send it buyer work, and the practices that make that work dependable. It is for the developer of the Agent, not for a sales or onboarding questionnaire.

What is enforced today

Routing buys by declared features is being rolled out. Today, when a buy has a property list, we send the list only to Agents that declare property-list support. We may still return Products from an Agent that does not declare support, and may send that Agent a buy without the property list. Declare every feature your Agent honours so the routing can apply it correctly. We calculate the seven-day behaviour baseline below from our calls to your Agent; How certification works says where you see it and which checks can stop new buys. A blocker on one of those checks stops your Agent’s certification pass counting, and an Agent without a current certification exemption takes no new buys until it is fixed. Our team reviews the calls we make to your Agent with you. Do not treat a missing block as permission to skip a requirement.

How we assess an Agent

We use evidence from our own calls to your endpoint. That includes the get_adcp_capabilities, sync_accounts, and get_products calls we make, as well as requests made while discovering inventory and handling buys. We measure the response your Agent sends, its timing, task progress, and whether returned products honour the request. We do not accept a self-reported claim as proof that an Agent behaves this way. Certification runs on this live traffic. The Agent page does not offer a separate transaction test to start. How certification works explains what makes an Agent ready, what each check judges, how long it takes, and what every result means. For each applicable use case, Apostra runs a small sandbox test buy and judges it from our tracker and the seller’s reports. Registering a production revision is not a prerequisite for testing or certification. A registered revision is useful for change detection, but it does not replace live-certification evidence. A passing use case completes the Successful transaction readiness check (publish_validation) for every Source that uses the Agent. The pass stands until a later certification result for the same use case and product family fails.

Tracker macro checks

For display, video, audio, CTV, and programmatic DOOH certification, Apostra checks only the tracker macros that the selected format declares and that apply to that certification use case. TMPX is not required for these standard macro checks. It belongs only to the separate Trusted Match certification for Agents that declare Trusted Match support.

Required declarations

AdCP 3

What it is. Your get_adcp_capabilities response must include major version 3 in adcp.major_versions. Responses must validate against the schema for the version we negotiate. Why buyers care. A buyer needs the same contract that your Agent says it supports, so a discovery result or buy does not fail when it reaches your system. How we measure it. We call your capabilities endpoint and validate the responses we receive at the negotiated version. See Getting ready for AdCP 4.0 for the capabilities we require, when, the checks we run and what to change.

A supported billing model

What it is. Declare agent, operator, or both in supported_billing. This is a seller-wide declaration, selected for each account in sync_accounts. We review advertiser billing case by case. Why buyers care. The billing model determines who can operate the buy and settle it without a manual intervention after the buyer is ready to transact. How we measure it. We read the billing declaration from the account and capability responses we call, rather than relying on a separate statement from your team. We then check that your Agent accepts the billing models it declares: a sync_accounts request for a declared model that your Agent refuses shows as a Declarations match behaviour finding.

Takes buyer account requests

What it is. Your Agent must list both sync_accounts and list_accounts and must not require operator authentication (account.require_operator_auth: true). Buyers declare their own accounts: sync_accounts receives a buyer’s account request, and list_accounts lets us read the result back. Why buyers care. Every buy runs on an account. A buyer can only start buying from you once your Agent can open an account for them. How we measure it. We read the tool list from your get_adcp_capabilities response. The Agent page shows the result as Takes buyer account requests in its required capability declarations. What happens when it is missing. When your Agent is the only source behind a storefront, we cannot open an account for a new buyer, so:
  • Certification skips with seller_sandbox_account_failed (or seller_operator_auth_unsupported), because it sets up its test account the same way.
  • An advertiser that does not already have an active account with you no longer sees your products in discovery and cannot book with you.
  • Advertisers whose accounts you already accepted keep discovering and buying as before.
Add both tools (and accept the connected credential) and refresh your Agent’s capabilities to open your storefront to new buyers again.

Creative formats we supply

What it is. At least one Product must declare a format. It can declare a canonical format_options[].format_kind that we support (display_tag, video_vast, or audio_daast), or legacy format_ids. Why buyers care. A buyer can only place a buy if Apostra can deliver a creative that the Product accepts and can measure. How we measure it. We inspect the Products returned by our own get_products calls.

Per-buy features

Property-list targeting

What it is. Property lists are a per-buy feature. In AdCP 3.1, declare media_buy.features.property_list_filtering and, for each applicable Product, property_targeting_allowed. If your Agent negotiates AdCP 3.2, also declare media_buy.execution.targeting.property_list and property_list_exclude, plus overlay_support.property_list on each applicable Product. Why buyers care. A property list lets a buyer direct a buy to the intended publishers, stations, or networks. It applies to every channel, including linear TV and radio. How we measure it. We read these declarations from the capability and Product responses we call. On buys that include a property list, we also check that the returned Products honour the property list, channels, and countries we sent. Property-list support is a per-buy requirement that is being rolled out; it does not block an Agent. Today, we send a property list only to an Agent that declares support. We may still return Products from an Agent that does not declare it and send that Agent a buy without the list. As feature routing rolls out, a buy that needs a property list will go only to Agents that declare support, while Agents that do not declare it can still receive buys that do not need it. Declare every feature your Agent honours.

Required behaviour

We assess these behaviours over the preceding seven days. A failure in this baseline applies to the Agent as a whole, not to one Product or one use case. Repeated means three or more events within the seven-day window. For this baseline, that applies to stale async handoffs and breaches of the request. Persistent means that the flagged condition appears on three or more separate days within that window.

Async tasks

AdCP 3.1 has no capability field for async tasks. We therefore assess them by behaviour, not declaration. If a request cannot finish in time, return submitted or working with a task handle. Then report a final status for the task within five minutes of our request, through polling or webhook. The responsiveness and async-completion rows above are how we assess that handoff. See Async completion finding for what counts as a final status.

Behaviour findings and how to fix them

Each row in the Agent’s Agent-wide behaviour list links to one section below. Every section gives the threshold, the usual causes, and the next step. We apply each threshold to every Source bound to the Agent separately, over its own seven days. The Agent-wide row shows the worst result among those Sources and adds up their counts. So “20 handoffs were still unfinished across one Source” means that Source has 20, not that the Agent has 20 in total. Open Source detail to see which Source needs work. A finding that says Not yet evaluated has no matching calls in the last seven days, so it is neither passing nor failing. It clears after we make the kind of call named in its section.

Responsiveness finding

Threshold. For each Source, over seven days:
  • Blocker: more than 5% of at least 20 get_products calls timed out. A call times out when it returns neither a result nor a task handle before the response deadline. By default that deadline is 45 seconds, counted from the moment we send the request. A buyer can set a shorter or longer budget.
  • Flag: the p95 time to answer get_products is over 10 seconds, and at least one call that took more than 10 seconds returned no task handle.
Usual causes.
  • The Agent builds the whole catalog during the request, for example by calling the upstream ad server live on every get_products.
  • The upstream ad server is slow or rate limiting the Agent.
  • Connection setup and cold starts use part of the deadline.
  • The Agent does not use a task handle, so a slow request can only succeed or time out.
Next step. Find the slow or timed-out get_products calls in your own logs for the window. If the Agent cannot answer within about 10 seconds, return submitted or working with a task handle straight away and finish the work in the background. Where you can, serve the catalog from a cache you refresh on a schedule.

Async completion finding

Threshold. A handoff is stale when your Agent answered submitted, working or pending, and five minutes after our request it had not reported a final status. Per Source: one or two stale handoffs is a flag; three or more is a blocker. The five minutes is fixed today and is not a per-task deadline you can set. A final status is completed, failed, rejected, canceled or input-required. A working update does not count. A task that finishes late stops counting at the next evaluation, once we have recorded its final status. Usual causes.
  • The job was lost after the Agent returned the task handle, for example because of a restart, a deploy, or a queue that drops work.
  • The Agent finished the work but never recorded the final status where polling reads it, or never sent it to the webhook.
  • The webhook call failed, for example on a wrong URL or an expired credential, and was not retried.
  • The work routinely takes longer than five minutes and only sends working updates.
Next step. List the task ids that were still open after five minutes in your own logs. For each, check that a final status is stored and that polling returns it. Check that the webhook call succeeds, and retry it when it fails. If a job needs longer than five minutes, it still counts as stale until it reports a final status, so report input-required, failed or completed as early as you can rather than only working.

Call success rate finding

Threshold. Over seven days, for each Source, the share of our calls that failed for a reason other than a timeout. A call fails when your Agent returns an error, rejects the request, or cancels it. Flag above 5%. Blocker above 20%, or when every call failed. This finding is Not yet evaluated until we have made at least one call. Usual causes.
  • Validation that is stricter than AdCP, so your Agent rejects a valid request.
  • Credentials for the upstream ad server that have expired or lost access.
  • An account that does not exist or is not active on your side.
  • An unhandled error inside the Agent, returned as a server error.
Next step. Group the failed calls in your own logs by error code and fix the most common one first. A single rejected field or an expired credential usually explains most failures.

Honours request finding

Threshold. We do not calculate this finding yet, so it never shows Flag or Blocker today. When we do, any breach will be a flag and three or more within the seven days will be a blocker. Usual causes. Products returned outside the property list, channels or countries we sent, for example because the Agent ignores a filter it does not support but did declare. Next step. No action is needed for this finding today. Make sure returned Products respect the property list, channels and countries in each request, and that you declare only the targeting you honour.

Account references resolve to one account finding

Threshold. Per Source: ACCOUNT_AMBIGUOUS returned once or more is a flag. It is a blocker when it appears on three or more separate days in the seven days. Usual causes.
  • Two accounts on your side share the same brand domain and operator, often because sync_accounts created a duplicate (see Account sync is idempotent finding).
  • The lookup matches on brand alone and ignores the operator or the sandbox flag.
Next step. Merge or deactivate the duplicate accounts so each key matches one account. Return an account_id on each account from sync_accounts; we then address the account by id instead of brand and operator.

Payment terms finding

Threshold. Counted for accounts we requested with agent billing and payment_terms. A missing billing or payment_terms, or an existing account kept on different terms, is a flag. A new account returned active on different terms is a blocker. The full rules are in Return and honour payment terms on agent-billed accounts. Usual causes.
  • The Agent gives every new account its own default terms and ignores the terms we request.
  • The account API your Agent calls cannot store payment terms.
  • The response leaves out billing or payment_terms.
Next step. For each agent-billed account we request terms for, either accept the requested payment_terms or reject the account. Never return it active on other terms. Return billing and payment_terms on every such account in sync_accounts and list_accounts.

Account sync is idempotent finding

Threshold. Per Source: a repeat sync_accounts that creates a second account for the same brand domain, operator and sandbox flag, or a list_accounts roster that lists one key more than once, is a flag. It is a blocker when this appears on three or more separate days in the seven days. Usual causes.
  • The Agent keys accounts on a generated id, or on brand alone, instead of brand domain, operator and sandbox flag.
  • A retry after a timeout runs the create again.
  • The sandbox flag is left out of the key, so a sandbox account and a live account collide, or the reverse.
Next step. Look up the account by brand domain, operator and sandbox flag before creating it. When it exists, return it with action: unchanged or updated and the same account_id. Merge the duplicates you already hold. Once each key is listed once, the finding clears as the seven-day window moves on.

Declarations match behaviour finding

Threshold. Today this finding checks billing. We count each sync_accounts request we sent in the seven days for a billing model you list in supported_billing. A request your Agent refused with BILLING_NOT_PERMITTED_FOR_AGENT or BILLING_NOT_SUPPORTED is a mismatch, whether the code came on the call itself or on the account in your answer. Any mismatch is a flag. A mismatch seen on three or more separate days is a blocker. When we sent no request for a billing model you declare, the finding is not evaluated. Usual causes.
  • supported_billing lists a billing model, such as agent, that your platform is not set up to accept for buyers.
  • The billing model is accepted only for some buyers or operators, but is declared for all.
Next step. Accept every billing model you list in supported_billing, or remove the ones you refuse. Buyers choose a billing model from your declaration, so a model you declare and then refuse leaves their account unopened. Once your Agent stops refusing a declared model, the finding clears as the seven-day window moves on. See Keep capabilities current.

Machine-readable errors finding

Threshold. Over seven days, any error we receive without a recognised AdCP error code is a flag. This finding is never a blocker on its own. Timeouts do not count here. Usual causes.
  • The Agent returns plain text, an HTTP status or a stack trace in place of an AdCP error.
  • The Agent passes through the upstream ad server’s error, or uses its own code that AdCP does not define.
Next step. Map every failure path to the nearest AdCP error code and return it with a message. Start with the errors that appear most in your logs.

What happens when we find a problem

A flag tells you what we observed and how to fix it. A blocker is shown on the Agent page. Running buys continue in both cases. How certification works says which checks can stop new buys. A blocker on one of those checks stops the Agent’s certification pass counting until the blocker clears, and an Agent without a current certification exemption takes no new buys while its pass does not count. A blocker on any other check leaves the pass alone. Our team reviews the evidence from our calls with you, and the thresholds on this page are the standard for that review.

Accept a sandbox account for certification

Before live-traffic certification can run its test buys for an Agent source, we set up a sandbox account on your Agent the way a real buyer would. We call your sync_accounts for our certification test buyer:
  • Brand: the certification advertiser’s brand domain, for example acmeoutdoor.example.
  • Operator: the buyer’s operator domain, for example pinnacle-agency.example.
  • Sandbox: sandbox: true.
  • Billing: a model your account.supported_billing offers. We request agent when you offer it, then operator, then advertiser. We request agent when your Agent declares none.
Your sync_accounts must accept a sandbox account for that test identity and return it with status: "active", sandbox: true, and an account_id. We use that account_id, and only that account_id, for creative sync and the certification buy. We never fall back to a default account or to the brand and operator alone. You do not choose or register an account yourself. Sandbox buys must still run through your real ad serving, at no cost to us. Certification creatives and buys do not wait in your Storefront’s creative review or media-buy approval queue, even when you approve those manually for buyers. They go straight to your Agent, which can still review or reject them the way your ad server normally does. A creative your Agent holds for review skips that family with seller_creative_review_required. A buy that our platform safety review holds is not sent, and the family is skipped with seller_approval_required. For a tracked certification family, the Product format selected for the buy must have a way to carry the buyer’s impression tracker. Declare an impression slot with asset_type: "url" and an id of impression, tracker_pixel, or imp_pixel; for hosted video or audio, declare a matching pixel_tracker slot. URL-delivered VAST and DAAST tags instead use the buyer’s hosted wrapper to carry the tracker. If the selected format has neither a supported tracker slot nor that wrapper path, certification cannot measure delivery and does not sync a creative or book a test buy for that family. Add a supported tracker path to the format, then start a new certification run. Certification skips a family, and records why, when one of these reasons applies. A skipped family never produced a buy. It shows as inconclusive with the reason, and it does not fail the use case. The Agent page shows the reason code with a short message and, when your Agent returned one, the first error code and message it sent. How certification works says what to change for each. A managed sales-agent source is certified the same way. We call the managed sales agent’s sync_accounts with the same brand, operator and sandbox: true, and request a billing model from the sales agent’s own account.supported_billing. We use the account_id it returns, unchanged, for creative sync and the certification buy. We do not use the certification buyer’s storefront account, the ad-server advertiser id, or a listing of the sales agent’s accounts. If the certification advertiser has no linked brand, certification skips that family with sandbox_brand_unverified.

Certification for an Agent that sells only through briefs

You do not need a wholesale listing to be certified. If your Agent lists no Products for a wholesale get_products and declares the brief buying mode in media_buy.buying_modes in get_adcp_capabilities, we certify it through briefs. You do not need to set media_buy.supports_proposals: that field says your Agent returns proposals, not that it takes briefs. An Agent that declares supports_proposals: true is certified through briefs too. An Agent that lists any wholesale Product is certified from that listing and is sent no brief. After the sandbox account is set up, we send one brief for each of these use cases: Each brief states a budget of USD 10 in total, the per-buy cap on every certification buy, and a three-day flight. We accept the first proposal, in the order you return them, with a Product that serves the use case, and we buy that Product at the pricing option the proposal allocates. If you answer with Products and no proposal, we treat the Products as your proposal. We buy through the same create_media_buy a buyer’s accepted proposal becomes, on the sandbox account_id you returned, and the buy is checked like any other certification buy. A Product serves a use case under the same rules as a wholesale Product: its channel, its creative kind, and a tracker path for the format. The buy must fit the USD 10 cap. When the only matching Product needs a minimum above it, the family is skipped as budget_exceeds_per_buy_cap so you can see the real obstacle. When your Agent returns nothing that matches, the family is skipped as buy_no_matching_proposal and its message says which brief came back empty. A skipped use case does not fail certification or stop the others.

How long certification gives get_products

Certification runs get_products three times: a brief, a wholesale listing, and a check that your Products are complete. Each call has the same 45 seconds a live buyer’s discovery gives your Agent, counted from the moment we send the request, so connection setup is part of it. An Agent that answers in 35 seconds serves buyers and passes certification. Other certification reads, such as listing audiences and event sources, keep a 30-second limit, and buy and creative operations keep 90 seconds. Certification runs started before this limit changed finish under the 30-second limit they began with, and an Agent’s existing certification stays valid until it expires.

Audiences and event sources

A buyer can map their own audiences and event sources to the ones already on their account with your Agent. Two declarations in get_adcp_capabilities decide which of your tasks we call for this: If your Agent declares neither, we never call either task to list or map objects. For listing and mapping, we read only these declarations, not your tool list. We are rolling these calls out to buyers in stages. Until a buyer is included, we make none of the listing or mapping calls below for that buyer’s accounts. Listing what is on the account. For each account a buyer connects through your Agent, we call each declared task in discovery mode, about once an hour. The request names the account and carries no audiences or event_sources list, so it changes nothing on your side. We call with the buyer’s own credential for that account. A malformed response, or one that reports errors, records nothing, and we try again on the next pass. Mapping. When a buyer maps one of their event sources to one of yours, we record which of your event sources, by seller_id, they picked. When a buy uses that mapping, we read your event sources again in discovery mode and confirm the one they picked is still listed and accepts the event types the buy needs. We record audience mappings too, but we do not confirm them on your Agent yet. Mapping never creates, changes or deletes anything on your Agent. Pushing audiences. When a buyer syndicates one of their audiences to your Agent, we send it with sync_audiences, including its members. This push depends on your tool list including sync_audiences, not on the audience_targeting declaration. We do not forward conversion events to your Agent with log_event yet. Certification checks the listing and mapping calls on your certification account; see Audience and event-source certification checks.

Audience and event-source certification checks

Certification adds checks for the buyer objects your Agent says it accepts. They run only when get_adcp_capabilities declares the matching AdCP 3.2 media_buy block, never because of your tool list, and they only read your certification account: If you declare conversion_tracking, keep at least one buyer-managed event source on your certification account, or the mapping check fails the run. Certification does not check log_event yet.

Best practices

These practices are not separate eligibility requirements, but they make an Agent easier to integrate and recover when something fails.

Return AdCP error codes

What it is. Return the applicable AdCP error code whenever an operation fails. Why buyers care. A structured error lets buyer software decide whether to retry, correct the request, or show the buyer the next action. How we measure it. We classify the errors returned by our calls. An error we cannot classify is visible in the behaviour review above.

Return an account ID from sync_accounts

What it is. When sync_accounts creates or confirms an account, return its account_id on that account’s row. Apostra stores the ID and sends account: { account_id } on later get_products and create_media_buy calls for that account, instead of the brand and operator. Keep the ID stable for the life of the account. A response row that names a different brand_id from the one we sent, or reports a failed action, is not taken as the account’s ID. Why buyers care. An ID names exactly one account. If the same brand and operator match more than one account on your side, the brand and operator alone return ACCOUNT_AMBIGUOUS, and the buyer’s discovery or buy fails. How we measure it. We read the account_id from the account rows in your sync_accounts responses, and the account-resolution results of the calls that follow.

Return and honour payment terms on agent-billed accounts

What it is. When we ask for an account with billing: "agent" and payment_terms (for example net_60), do one of two things: accept those terms, or reject the account. Never return the account as active on different terms. On every account in your sync_accounts and list_accounts responses for an account we requested this way, return billing and payment_terms so we can see what you hold. AdCP states that the seller “must either accept these terms or reject the account — terms are never silently remapped.” Why buyers care. The buyer’s organization chose its payment terms. An account on other terms means invoices that don’t match what they agreed. What Apostra does when an Agent doesn’t. We refuse a new account that comes back on other terms. It is not activated, and it is held for the buyer to review the seller’s terms. An existing account stays usable, and the buyer sees a warning that names both the requested terms and the terms your Agent kept. How we measure it. We compare the accounts in your sync_accounts and list_accounts responses over the last seven days with the terms we requested. Only an account we requested with agent billing and payment_terms in that window counts. An account we requested without terms is on your default terms, as AdCP says, and isn’t counted. An account we never requested in the window isn’t counted either, and a response from before our request doesn’t count against the account. We don’t assume what your default terms are. For a counted account, a missing billing or payment_terms is a flag, and an active account on different terms is a blocker when your Agent created it or activated it on those terms, and a flag when your Agent already held it. Your Agent already held it when its sync_accounts response reports action: unchanged, or action: updated after an earlier response held the account active. A response that reports action: created or no action counts as a new account. An account that was a blocker at any point in the seven days stays one. A counted account whose listing has no billing counts as missing billing. We count accounts, not responses: an account is identified by its brand domain, operator and sandbox flag (and its brand id and operator unit, when you return them), however often it appears in your responses. An account counts as missing a field only while its latest response in the window lacks it, so it stops counting once your next response is complete. From list_accounts we read only your most recent roster, which is every page of your latest complete listing, so an account that has dropped out of it isn’t counted. An account returned on different terms stays counted for the seven days. This check reports today and does not yet stop new buys.

Sync accounts idempotently

What it is. The account key is the brand domain, the operator and the sandbox flag. When we send sync_accounts for a key your Agent already holds, return that same account with action: unchanged (or updated, if something changed) and the same account_id. Create an account only the first time the key appears. list_accounts lists each key once. Why buyers care. A buyer syncs the same account again whenever their setup changes. If each call creates a new account, the buyer’s buys, approvals and invoices spread across accounts nobody asked for, and the seller cannot tell which one is current. How we measure it. Over the last seven days we look for two things: two or more sync_accounts responses that report action: created for one key under different account_id values, and a list_accounts response that holds more than one account for the same key and sandbox flag. We read a list_accounts roster as every page of one listing, joined by pagination.cursor, and use the latest listing whose last page returns has_more: false; a listing that stops early isn’t used. Seeing either is a flag. Seeing it on three or more days is a blocker. A sandbox account and a live account for the same domain are different keys. Once your Agent merges the duplicates and lists each key once, the roster signal clears. This check reports today and does not yet stop new buys.

Hand off long work quickly

What it is. Return submitted quickly when work needs more time, with a task handle that callers can poll or receive by webhook. Why buyers care. The buyer gets a durable acknowledgement instead of waiting for a request that will exceed the response window. How we measure it. We record the initial response time, task handle, and later task status from our calls.

Declare AdCP channels on every Product

What it is. Every Product declares the AdCP media channels it sells in channels, such as display, olv, ctv, or streaming_audio. A Product that sells different channels through different formats can instead declare applies_to_channels on each format option. A format type on its own, such as a video or audio format, is not a channel, because several channels share a format. Why buyers care. Buyers filter discovery, route proposal requests, and report delivery by channel. A Product with no channel is missing from channel-filtered discovery, and its delivery reports with no channel. How we measure it. We read channels, then applies_to_channels, on the Products returned by our get_products calls. Storefront readiness counts the Products that declare neither (see Diagnostics), your Agent page shows the same count as an advisory note under Catalog Product Quality, and live-path certification skips such a Product with the reason missing_channels rather than certifying it on a guessed channel. When a Product relies on applies_to_channels and only some of its format options declare it, the other formats are skipped with the reason missing_channels:<format_kind>. This is a best practice: a missing channel produces a warning and never blocks your Agent or fails its certification. We do not refuse an external Agent’s Products for missing channels. AdCP is considering making channels required on every Product in AdCP 4.0 (adcontextprotocol/adcp#7869); if it does, AdCP compliance will require it.

Declare every targeting dimension you honour

What it is. Declare each targeting dimension your Agent and Products will honour, and do not declare dimensions that your upstream system ignores. Why buyers care. Buyers use declarations to choose inventory that can meet their brief. An incomplete declaration excludes compatible buys; an inaccurate one can route a buy that cannot meet its targeting. How we measure it. We compare declared capabilities with the request and Products returned by our discovery and buy calls.

Keep capabilities current

What it is. Update capability, account, and Product declarations whenever the upstream system changes what your Agent can do. Why buyers care. Current declarations prevent a buyer from selecting inventory that has changed, disappeared, or no longer supports a required feature. How we measure it. We use the current responses from our calls and compare them with the behaviour we observe. If the two disagree, the declarations-match- behaviour requirement applies. For the full build and launch path, see Build and launch a Sales Agent.