DEV Community

Aleksander Sekowski
Aleksander Sekowski

Posted on

11 ARTF Envelope Errors That Return gRPC OK and Still Kill Fill

On 10 November 2026 IAB Tech Lab refreshed its ARTF standards page: v1.0 is final, v2.0 is in the working group, and production hosts are expected to chain orchestration so one sidecar can call another and merge mutations before OpenRTB leaves the platform. That merge step is where envelope metadata matters as much as intent lines. Kubernetes reports the container healthy; gRPC returns OK; the ticket still misses the exchange because lifecycle was unspecified, tmax was a string, or the carried bid request was legal JSON that was not legal OpenRTB.

ARTF is not a replacement auction protocol. It wraps the same bid request buyers already parse. Engineers who previously audited only mutation protobuf after a green RPC need a second pass on the envelope: lifecycle stage, originator, timeout budget, and the OpenRTB blob inside RTBRequest or RTBResponse. These eleven failures show up as fill loss with no mutation intent to grep.

Eleven envelope errors that clear the sidecar and still cost fill

  1. Carried OpenRTB that is JSON but not an object. Agents sometimes return an array, a stringified subtree, or JSON with a trailing comma. Protobuf may still carry bytes; artf.payload.invalid_json means apply never receives a walkable root. The host forwards the pre-agent ticket and you bill for a no-op.

  2. Missing required envelope members. Omitting a field the host profile treats as mandatory (for example originator metadata the orchestrator logs for audit) still parses in loose mode. artf.field.required fires when your conformance pack is stricter than the agent's generator. gRPC succeeds; the host drops the response for policy, not syntax.

  3. Lifecycle left unspecified on a staged ticket. The host must know whether this hop is publisher request or DSP response work. Unspecified lifecycle means intents that belong on the response object get evaluated against the wrong payload slot: artf.lifecycle.unspecified. Curators see an empty mutation list after merge.

  4. Lifecycle declared on the envelope but payload type disagrees. An RTBResponse frame tagged as publisher bid request produces artf.lifecycle.payload_mismatch. Container CI often checks only one golden file; production alternates request and response in the same deployment.

  5. tmax serialized as a float. Auction clocks are integers. "tmax": 120.0 is a classic LLM output. artf.tmax.not_integer is envelope-level damage: the host may clamp, reject, or pass garbage into OpenRTB tmax depending on merge rules.

  6. Zero or negative tmax on the ARTF hop. Non-positive values pass casual schema review and fail artf.tmax.non_positive. The exchange never sees the patch because the orchestrator already gave up on the deadline.

  7. Implausible tmax relative to the incoming auction. An agent that sets tmax to 5000 ms on a 120 ms SSP slice looks syntactically fine and trips artf.tmax.implausible when the host enforces parent bounds. You lose the race before DSPs parse imp.

  8. Unknown originator type on a multi-tenant host. Shared platforms need to know whether the patch came from curator, buyer agent, or nested orchestration. artf.originator.type_unknown is policy and telemetry, but hosts that reject unknown types drop the whole RPC result even when gRPC was green.

  9. Protobuf JSON type drift on envelope scalars. Strings where enums or bools belong still deserialize in forgiving parsers; strict hosts fail artf.field.type_mismatch. The failure is on the framework object, not inside a mutation line.

  10. ADD_METRICS with an empty metrics list. Intent and operation parse; the metrics oneof is present but empty: artf.mutation.metrics_empty. Orchestrators may accept the RPC and skip apply, leaving revenue tools blind on the cleared request.

  11. Mutation without path when the intent requires one. Some generated templates emit intent and payload but omit path. artf.mutation.path_missing is an envelope-adjacent contract break: the sidecar returns OK, the merge step has nothing to anchor. Chained orchestration from v1.0 makes this worse when child node responses concatenate invalid rows before the parent validates.

How you catch it

Validate the ARTF request or response envelope first, then mutations, then apply and revalidate OpenRTB on the object the exchange will fan out. The ARTF simulator runs that order in a browser. CLI:

$ rtblint validate --type artf-request rtb-request.json
$ rtblint validate --type artf-response --apply \
    --request rtb-request.json rtb-response.json
Enter fullscreen mode Exit fullscreen mode

An LLM implementing ARTF or ARTF orchestration can emit protobuf JSON that passes its own client and still leave a bid the exchange cannot use. rtblint (cargo install rtblint, npm install rtblint-core, MCP rtblint-mcp) is the deterministic check on that envelope, mutation set, and post-apply OpenRTB object. It is independent of IAB Tech Lab and of AAO; the spec does not require it.

Where to go next

Top comments (0)