EU AI Act Article 50: the compliance clock on generative media is already running

On 2 August 2026, Article 50 of the EU AI Act starts applying to generative AI systems placed on the EU market. If your product ships images, video, or audio that a model made, the law now has an opinion about your pipeline — specifically, about whether your outputs are marked in a machine-readable format and detectable as artificially generated. Most teams we talk to have read the headline and stopped there. The details are where the work is — and the first detail is which duty is even yours.

Two duties, not one: the provider/deployer split

Article 50 is the AI Act's transparency chapter, and its generative-media obligations split cleanly in two — which is the part the one-paragraph summaries miss:

• Article 50(2) — the provider duty. "Providers of AI systems, including general-purpose AI systems, generating synthetic audio, image, video or text content" must ensure the outputs are marked in a machine-readable format and detectable as artificially generated or manipulated. This is the marking obligation.
• Article 50(4) — the deployer duty. Deployers must disclose deep fakes, and disclose AI-generated text published to inform the public on matters of public interest — unless the content passed human editorial review with a person holding editorial responsibility (the "editorial exemption").

The split matters because most companies assume both duties belong to whoever trained the model. They don't. If you call a model over an API and put its output in front of users under your own name, you are very likely the provider of a generative AI system, and the 50(2) marking duty is yours — even though you trained nothing. We wrote that argument up separately, because it is the single most-missed point in the whole regulation: you didn't train a model, and you're still a provider.

What makes Article 50 different from the average compliance memo:

It's also testable. "Machine-readable" is not a vibe: either a program can read the marking off your output bytes or it can't. That makes Article 50 unusually easy for a regulator — or a journalist — to check from the outside, with no subpoena required. Download the asset, inspect it, publish the result.

The Code wants two marking layers — and doesn't name C2PA

The Act itself is technology-neutral. The Commission's Code of Practice on Transparency of AI-Generated Content — the voluntary companion, final version published 10 June 2026 — is where the technical shape lives, and it is more demanding than "embed one manifest." Because no single technique satisfies all four of 50(2)'s requirements under the current state of the art, the Code requires at least two layers of machine-readable marking:

• Sub-measure 1.1.1 — digitally signed metadata. A signed, time-stamped, tamper-evident manifest. This is the category C2PA Content Credentials implements — but note the Code describes it generically and does not name C2PA. C2PA is the dominant real-world implementation, not a cited standard.
• Sub-measure 1.1.2 — imperceptible watermarking. A robust watermark that survives the re-compression, cropping, and screenshotting the Code enumerates elsewhere.
• Sub-measure 1.1.3 — fingerprinting or logging (optional). Supplementary. The Code states plainly that "relying on fingerprinting or logging alone is not considered sufficient."

Here is the part that surprises engineering teams, restated correctly: for many pipelines the signed-metadata layer is already there at the source. If you generate through a provider that embeds C2PA, that first layer leaves the model with the output. Your job is then two things — don't destroy it, and understand that on its own it may not be enough, because the Code wants a second, watermark layer alongside it.

The hard part of Article 50 has two halves: getting two marking layers onto the output, and running a pipeline that doesn't strip them between the model and the user.

Content Credentials are metadata cryptographically bound to specific bytes. Re-encode the file, resize it, run it through an image-optimizing CDN, screenshot it into a marketing deck — the manifest is gone, and with it that layer of your machine-readable marking. We wrote up where credentials die in real pipelines separately; the summary is that almost every convenience feature of a modern media stack is hostile to them by default, which is precisely why the Code asks for a second layer that can survive those hops.

Marking is the floor. Evidence is the job.

Suppose it's March 2027 and a market-surveillance authority — or your own enterprise customer's procurement team — asks a simple question: "Show us that this asset, published on this date, was marked as required." A screenshot of your provider's documentation is not an answer. What answers it:

• A generation record — which model, which provider, which parameters, at what time, tied to the asset. Recorded when it happened, in a store that can't be quietly edited.
• The exact bytes — the output as produced, with a hash computed at ingestion, so you can demonstrate the published asset is (or derives from) the marked original.
• Lineage — when assets chain (a generated image animated into a video, then dubbed), the path from final asset back through every intermediate job and input.

Be precise about what that record is, though: in the Code's taxonomy it is logging (the 1.1.3 layer), and logging alone is expressly not sufficient marking. It is the evidence that discharges an audit, not the mark itself — a log is not a mark, and pretending otherwise is exactly the move an honest verifier shouldn't make. The artifacts that produce this evidence are an append-only event ledger, byte-exact custody, and a lineage graph — pipeline properties you either built in or didn't.

What to do this quarter

• Work out which duties are yours. Provider (50(2) marking), deployer (50(4) disclosure), or both. If you ship a branded generative feature, assume 50(2) is in scope until counsel tells you otherwise.
• Inventory your generative surfaces. Every place your product emits synthetic media, including the ones marketing runs through a design tool afterwards. The December grace period for existing systems means the legacy surfaces count too.
• Check what your providers embed — and what they don't. Generate a real output on each provider and inspect it (the c2patool CLI reads manifests). Expect to find the signed-metadata layer on some and neither layer on others — and remember one layer may not be enough.
• Audit the path to the user. Trace one asset from generation to the pixels a user sees. Every transform in between — thumbnailer, CDN optimizer, format converter — is a place the marking dies.
• Start recording now. Evidence has a start date. A ledger you stand up in July 2026 can't testify about June.