C2PA is not an AI detector, and that is the point

I keep coming back to one question:

Why are we still asking whether something is "AI generated" as if that were a useful yes-or-no question?

A photo can be taken by a human, cropped in software, denoised by an AI model, color corrected by a photographer, upscaled by another model, and then approved by an editor.

Is that AI generated?

Maybe. Maybe not. The label does not tell me much.

Same with writing. A blog post can start as my idea, go through an AI draft, get rewritten by me, be checked against sources, translated, edited again, and then published after a final human review. Calling the final text "AI generated" hides almost everything that matters.

That is the part that bothers me.

The public discussion often wants a detector. Upload an image, press a button, get a verdict: human or AI. Clean, simple, and mostly wrong.

C2PA is interesting because it does not try to be that. It asks a different question:

What can we say about the origin and history of this asset, who is saying it, and can we detect whether that signed information still matches?

That is much more useful.

What C2PA actually is

C2PA stands for Coalition for Content Provenance and Authenticity. It is an open technical standard for attaching signed, tamper-evident provenance data to digital content.

In plain language: C2PA lets a file carry a kind of history card.

That history card can include things like where an asset came from, which previous assets were used, which actions were recorded, which tool made an assertion, and who signed it.

The user-facing version of this idea is usually called Content Credentials. I like the "nutrition label" analogy people use for it. You do not look at a nutrition label and expect it to prove that the food is morally good. You look at it because it gives you structured information. Ingredients. Source. Processing. Maybe certification.

You still have to think.

C2PA works in a similar way for digital media.

The technical model uses words like assets, manifests, assertions, claims, actions, ingredients, and signatures. Dry words, but the basic model is not that hard.

An asset is the thing itself: an image, video, audio file, document, or another piece of content.

A manifest is the provenance package associated with that asset. In the user interface, this may show up as Content Credentials.

Assertions are statements inside the manifest. For example: this was edited in this software, this file includes this source asset, or this metadata was provided by this actor.

Actions describe things that happened, at least as far as the recording tool or actor asserts them. Cropped. Resized. Generated. Edited. Exported.

Ingredients are source assets used to create the current asset. If I combine a photo, a generated background, and a logo, those can be ingredients.

Signatures connect the statements to a signer. They do not make the statements true by magic. They show who asserted them and whether the signed data still validates.

That distinction matters.

C2PA is not a truth machine. It is a provenance standard.

Why "AI detector" is the wrong frame

People want AI detectors because they want certainty. I understand that.

Teachers want to know whether a student wrote the essay. Newsrooms want to know whether an image came from the event it claims to show. Platforms want to label synthetic media. Readers want to know whether they are being fooled.

But detectors are brittle. They infer from patterns. They guess.

Sometimes the guess is useful. Often it is not.

A detector can be fooled by editing, compression, translation, rewriting, screenshots, or just by ordinary human writing that happens to look statistically "AI like". And even if the detector is correct, the result is still too coarse.

A fully generated image of a politician at an event that never happened is one thing.

A real press photo where the background was slightly blurred with an AI tool is another.

Both may trigger an AI signal. They are not the same problem.

Same with writing. A spam article generated with no human review is not the same as a technical post based on my own work where I used an AI assistant to restructure a paragraph and then checked every claim.

The "AI generated" label collapses different workflows into one bucket.

That is why provenance matters more than detection. I do not only want to know whether AI touched something. I want to know how it touched it, when, and under whose responsibility.

Was AI used to create the original image? Was it used only for cleanup? Was a human editor involved after the last AI change? Which source assets went into it? Who is willing to sign that claim?

Those are better questions.

A practical example

Take a simple image workflow.

A photographer takes a picture at a demonstration with a camera that supports C2PA. The camera creates a file and signs provenance data. Later, the photographer opens it in editing software, crops the image, adjusts exposure, and exports it. The software records those actions and signs the new manifest. A newsroom receives it, verifies what it can, and publishes it with Content Credentials visible to readers.

A reader can inspect the credentials and see a signed history: capture, edits, publication.

That does not prove the photograph "tells the truth". The photographer may have chosen a misleading angle. The newsroom may have selected one frame out of hundreds. The recorded metadata may be incomplete. A tool in the chain may not support C2PA. A signer may be trusted in one context and not in another.

But it gives the reader more than a naked JPEG.

Now compare that with an image found on a random social account with no visible provenance. It may still be real. Missing C2PA does not mean fake. But the trust situation is different. There is no signed history to inspect.

That is the kind of nuance we need more of.

What C2PA does not solve

C2PA does not prove that content is true.

A signed image can still be misleading. A signed video can still be staged. A signed article can still contain errors.

C2PA also does not guarantee that metadata is honest.

It can show who asserted something and whether the signed information still validates. But if a trusted actor signs a weak or incomplete claim, the signature does not fix that. Trust still depends on the signer, the context, and the verification policy.

C2PA does not force adoption either.

Some tools do not support it. Some platforms strip metadata. Screenshots and format conversions can break chains. Some credentials may be embedded, some may be external, and some may be missing completely.

That is messy, but it is also the world we have.

There is another limitation I care about for HACP: C2PA records provenance, but complex human and AI workflows can have more structure than a simple list of actions.

Where HACP v0.3 is going

After the C2PA community discussion around HACP, I changed how I think about the project.

HACP v0.3 should not be a parallel provenance standard. That would be the wrong direction. C2PA already exists for signed content provenance, and CAWG is building related assertion work around identity, creators, rights, consent, training and data mining, and similar topics.

The more useful question is narrower:

How can C2PA and related work describe the causal structure of modern human and AI workflows better?

Here is the practical version.

Human concept
AI draft
Human review
AI rewrite
Human fact check
Human final approval

If we only record a flat list of actions, we lose something important. Order helps, but it may not be enough.

A final human approval matters only if it happened after the last AI modification. If the approval happened before the AI rewrite, then the final published text was not approved in the way a reader might assume.

That is not a philosophical detail. It changes accountability.

For me, this is the interesting gap. Not "was AI involved?" but "what depended on what?"

In HACP v0.3 I am exploring whether this can be expressed inside the C2PA world, for example with experimental namespaced action parameters such as:

com.bajonczak.hacp.actionId

and

com.bajonczak.hacp.dependsOn

The idea is simple. Give actions stable identifiers, then allow later actions to say which earlier actions they depended on.

An AI rewrite could depend on a human review. A final human approval could depend on the AI rewrite and the fact-checking step. A source verification action could depend on the original draft and external references.

This is experimental. It is not part of the C2PA standard. I do not want to overclaim it.

But I think this kind of structure could help describe iterative workflows more honestly, especially the messy ones where humans and AI systems go back and forth.

Why causality matters more than labels

The current label debate often treats AI as contamination. If AI touched the file, the file belongs in one category. If not, it belongs in another.

That is too crude for actual work.

In my own workflows, I care about responsibility. If I use an AI tool to brainstorm ten possible titles and then write the post myself, the AI's influence is real but limited. If I ask a model to produce a first draft and publish it without checking, that is very different. If I use AI to translate my own German notes into English and then edit the result, that is different again.

The contribution semantics matter.

Was the human contribution a concept, a review, fact checking, final approval? Was the AI contribution drafting, rewriting, image generation, cleanup, or summarization? Did one step depend on another? Could the later actor see the earlier output? Did the final accountable person approve the final state?

These questions are not answered by "AI generated: yes/no".

They are also not fully answered by basic provenance records, at least not in the way I would like for complex workflows. But C2PA gives us a foundation: signed assertions, actions, ingredients, and validation.

HACP, if it is useful at all, should fit into that world rather than compete with it.

A better mental model

The mental model I use now is this:

C2PA is the envelope and verification layer for provenance.

Content Credentials are the readable label people can inspect.

CAI helps with adoption, awareness, and tooling around content authenticity.

CAWG works on creator, identity, rights, consent, and related assertions on top of C2PA.

HACP should explore how to express causal workflow structure, especially in human and AI loops, in a way that can live with C2PA rather than beside it.

That separation makes the work cleaner.

It also avoids the trap of inventing yet another standard because the existing one does not express every nuance I care about. Sometimes the right move is not to replace the base layer. Sometimes it is to test a small extension, bring the question back to the community, and see whether it belongs in the standard, in a profile, or nowhere at all.

That is why I opened the C2PA specifications issue about iterative and causally dependent actions.

I do not know the final answer yet. But I think the question is worth asking:

How should iterative and causally dependent actions be represented in C2PA?

If the answer is "use existing action parameters", fine. If the answer is "this belongs in CAWG", also fine. If the answer is "this model is too complicated for what C2PA should carry", that is useful too.

The point is to make the workflow visible enough that people can reason about it.

Conclusion

C2PA is not an AI detector.

Good.

We do not need more magical verdict machines pretending to separate human from synthetic with perfect confidence. We need better records of how content was made, changed, signed, and approved.

C2PA gives us a practical base for that. It can carry provenance. It can make tampering visible. It can show who asserted what. Content Credentials can make that information readable.

But provenance is not truth. A signature is not honesty. Missing credentials are not proof of fakery. And complex human and AI workflows still need better ways to express causality, review, approval, and responsibility.

That is where I want to take HACP v0.3: not as a competing standard, but as a small exploration of how causal workflow semantics might fit into the C2PA ecosystem.

The better question was never only "is this AI generated?"

The better question is:

What happened, in what order, based on which inputs, and who is willing to stand behind the final result?

Links and sources

• C2PA: https://c2pa.org/
• C2PA specifications and explainer: https://github.com/c2pa-org/specifications
• Content Credentials: https://contentcredentials.org/
• Content Authenticity Initiative: https://contentauthenticity.org/
• Creator Assertions Working Group specs: https://cawg.io/specs/
• HACP specification repository: https://github.com/SBajonczak/hacp-spec
• C2PA issue 127, "How should iterative and causally dependent Actions be represented in C2PA?": https://github.com/c2pa-org/specifications/issues/127