
There is a requirement landing on 2 December 2026 that most teams have filed under "legal will handle it": AI-generated content must be marked as artificially generated in a machine-readable way.
It is not a legal task. It is a pipeline task, and it fails in a specific place that nobody is looking at.
The requirement, briefly
Under the EU AI Act's transparency provisions, synthetic image, audio, video and text output needs to be identifiable as machine-generated. The operative word is machine-readable — a visible caption in your UI does not satisfy it, because the marking has to survive the content leaving your interface.
In practice, for images and video, this converges on C2PA Content Credentials: a cryptographically signed manifest embedded in the file describing what created it, when, and with which tool.
Most model providers now emit these. So the naive assumption is that you get compliance for free by using a provider that signs its output.
You do not, and here is why.
Where it actually breaks
Your pipeline destroys it.
Trace what happens to a generated image between the model and the user:
model output (signed, credentials intact)
→ upload to object storage ✓ usually fine
→ thumbnail generation ✗ metadata stripped
→ format conversion to WebP/AVIF ✗ metadata stripped
→ CDN image optimisation ✗ metadata stripped
→ responsive srcset variants ✗ metadata stripped
→ delivered to user (nothing left)
Every one of those steps is a routine performance optimisation. Every one of them, by default, discards metadata — because metadata makes files bigger and image tooling has spent twenty years learning to remove it.
Nobody decided to strip the credentials. It is an emergent property of a pipeline built entirely for byte size, at a time when nothing depended on the metadata surviving.
This is the compliance failure I would bet on finding in most organisations right now, and it will not show up in any policy review, because the policy says "we mark AI-generated content" and that statement is true at the point of generation.
Testing whether you have the problem
Five minutes, right now:
# Install the C2PA CLI
cargo install c2patool # or download a release binary
# Check the source, straight from your model provider
c2patool generated-original.jpg
# Now check what your users actually receive
curl -sL "https://yourcdn.example.com/generated-image.jpg" -o delivered.jpg
c2patool delivered.jpg
If the first prints a manifest and the second prints nothing, you have the problem. In our experience that is the common outcome, not the exception.
Do the same for any third-party generated content transiting your platform. If a partner's content arrives signed and leaves stripped, you have manufactured a problem that did not exist upstream.
Fixing it
Four things, roughly in order of value.
1. Preserve metadata explicitly at every transform.
Most image libraries can retain it if asked, though the flag is rarely the default:
# ImageMagick — strip is often the default in build scripts, check yours
magick input.jpg -resize 1600x -define preserve:metadata=true output.jpg
# sharp (Node) — withMetadata() is opt-in
sharp(input).resize(1600).withMetadata().toFile(output)
# ffmpeg — map metadata explicitly
ffmpeg -i in.mp4 -map_metadata 0 -movflags use_metadata_tags out.mp4
Be aware that generic metadata preservation is necessary but not always sufficient: a C2PA manifest is signed over the content, so a transform that alters pixels invalidates the original signature even when the bytes are carried across. The correct pattern for a transform you control is to re-sign, recording the transform as an assertion in the new manifest — that is what the C2PA model is designed for.
2. Verify at the egress boundary, not at generation.
Generation-time verification confirms the step that was already working. Put the check where content leaves your control.
3. Add a CI test over the whole pipeline.
This is the durable fix, because the failure will otherwise be reintroduced by a future performance optimisation:
test('content credentials survive the delivery pipeline', async () => {
const generated = await generateTestImage()
expect(await hasValidManifest(generated)).toBe(true)
const delivered = await fetchThroughFullPipeline(generated) // storage → transform → CDN
expect(await hasValidManifest(delivered)).toBe(true)
})
Someone will add an optimisation step in eighteen months without knowing about any of this. The test is what stops that from silently becoming a compliance regression.
4. Handle text separately.
Text has no equivalent of an embedded signed manifest that survives copy-paste, and honest engineering here means acknowledging the limits. What is defensible: recording provenance server-side against a content ID, marking generated text in your own data model and APIs, and disclosing clearly in the interface. Watermarking techniques for text exist but are fragile under paraphrase and editing — do not present them as stronger than they are.
The data model implication
One design point that gets missed: if your product mixes AI-generated and human-authored content, "is this AI-generated" has to be a field, not an inference.
Teams frequently try to derive it after the fact — from which endpoint created the record, or a naming convention, or a timestamp correlation. That is guesswork, and it fails exactly when a mixed-authorship record exists: a human edits an AI draft, and now the record is neither cleanly.
Model it explicitly at creation:
ALTER TABLE content_items ADD COLUMN generation_source TEXT NOT NULL; -- 'human' | 'ai' | 'ai_edited'
ALTER TABLE content_items ADD COLUMN generating_model_id UUID REFERENCES model_registry(id);
ALTER TABLE content_items ADD COLUMN human_editor_id UUID;
Retrofitting this is unpleasant, because existing rows have no recoverable answer.

Why this is urgent rather than merely good practice
The EU deferred its high-risk AI obligations — December 2027 for standalone systems, August 2028 for product-embedded ones. Many teams read that as general breathing room.
The transparency and content-marking obligations were not deferred. They land on 2 December 2026. And if your product is not high-risk, which most are not, none of the deferral applied to you anyway.
Which makes this the nearest real deadline for the majority of teams shipping AI features, and it is the one being least discussed.
Full regulatory context and what else belongs in the architecture: AI Regulations in 2026: What Product Teams Must Build Now.
We build software, not legal advice — verify specifics with counsel.
Frequently Asked Questions
Does C2PA survive a screenshot? No. Screenshots produce entirely new files with no relationship to the original. This is a known and accepted limitation of embedded provenance — the goal is establishing a verifiable chain for content that moves normally, not defeating deliberate laundering.
Do we need to sign content ourselves, or is the model provider's signature enough? The provider's signature covers their generation step. Once you transform the content you have invalidated it, so you need to re-sign and record your transform as an assertion. That requires your own signing certificate.
What about audio and video? Same principle, and the same failure mode — transcoding strips metadata unless explicitly mapped across. Video is worse in practice because transcoding is near-universal in delivery pipelines.
Is there an equivalent for text? Nothing robust that survives copy-paste. Record provenance server-side against a content ID, mark it in your data model and APIs, and disclose in the UI. Do not overclaim the strength of text watermarking.
How much work is this overall? Four to eight weeks for most teams, depending on how many surfaces generate content and how many transform stages exist. The CI test is a day and prevents the most likely regression.
What if we use a third-party CDN we cannot configure? Check whether metadata preservation is available as a setting — most major providers now offer it, precisely because of this requirement. If not, serve provenance-critical assets from a path that bypasses optimisation, and treat that as a procurement question at renewal.
TechCirkle builds AI systems with governance and provenance from the first sprint. AI development services · talk to us