Human Creative Input & Copyright

A human’s authored prompt document, concept note, or creative brief can be recorded as a resource and referenced as an input to an AI action — making the provenance graph machine-readable evidence of human creative contribution.

Legal Context

US Copyright Office (2025 report): AI-generated content is not copyrightable, but human-authored inputs to an AI (prompts, selection, arrangement, editing) can constitute sufficient creative contribution for copyright protection. USCO guidance: The more a human’s creative choices are recorded and evidenced, the stronger the copyright claim over the resulting work. EU AI Act Art. 50: Requires disclosure of AI involvement in content creation. This pattern provides the data foundation for these claims. ProvenanceKit does not make legal determinations — it gives developers and legal practitioners the provenance data to build on.

The Core Insight

Instead of a single AI-creates-content relationship:

[AI Action: generate] ──► [Output: poem.txt]

Record the human input explicitly:

[Human resource: prompt.txt] ──┐
                                ├── [Action: create] ──► [Output: poem.txt]
[AI tool resource: gpt-4o]  ──┘

The human’s prompt document is a resource in the EAA graph — it has a CID, it’s an input to the action, and the human creator is the entity who created it.

Recording the Pattern

import { ProvenanceKit } from "@provenancekit/sdk";
import { withExtension } from "@provenancekit/extensions";

const pk = new ProvenanceKit({ apiKey: "pk_live_..." });

// 1. Record the human's authored input (prompt, brief, concept note)
const humanPrompt = await pk.file(
  Buffer.from("Write a sonnet about the ethics of AI in the style of Shakespeare..."),
  {
    entity: {
      id: "user:alice",
      role: "human",
      name: "Alice",
    },
    action: { type: "create" },
    resourceType: "text",
  }
);
// humanPrompt.cid = "bafybei..." — the prompt is now a content-addressed resource

// 2. Record the AI-generated output, referencing the human prompt as input
const { cid: outputCid } = await pk.file(
  Buffer.from(aiGeneratedPoem),
  {
    entity: { id: "app:poetry-service", role: "organization" },
    action: {
      type: "create",
      inputCids: [humanPrompt.cid],   // The human's prompt IS an input
      extensions: {
        "ext:ai@1.0.0": {
          provider: "openai",
          model: "gpt-4o",
          autonomyLevel: "assistive",   // Human directed; AI executed
          promptCid: humanPrompt.cid,   // Explicit reference
        },
      },
    },
    resourceType: "text",
  }
);

// The graph now shows: alice ──creates──► prompt ──inputs──► action ──produces──► poem

What Gets Recorded

alice (entity: human)
  └── creates ──► prompt.txt (resource: text, CID: bafybei...)
                    └── used as input to ──►
                                           action: create
                                             ├── performedBy: poetry-service
                                             ├── ext:ai@1.0.0: { model: gpt-4o, autonomyLevel: "assistive" }
                                             └── produces ──► poem.txt (resource: text, CID: bafybej...)

The provenance graph is machine-readable evidence that:

A human (Alice) authored the prompt
The prompt was an input to the AI action
The AI acted at an “assistive” autonomy level (human-directed)
The output is the generated poem

Autonomy Levels

The autonomyLevel field in ext:ai@1.0.0 signals the degree of human creative control:

Level	Meaning	Copyright implication
`"autonomous"`	AI acts independently, minimal human direction	Weakest copyright claim for human
`"supervised"`	Human reviews and approves AI outputs	Moderate human creative contribution
`"assistive"`	Human directs the AI with detailed instructions	Strongest human copyright claim

Richer Creative Inputs

For more complex creative workflows, record each human input separately:

// Design brief
const brief = await pk.file(designBriefBuffer, {
  entity: { id: "user:designer", role: "human" },
  action: { type: "create" },
  resourceType: "text",
});

// Style reference image
const styleRef = await pk.file(moodBoardBuffer, {
  entity: { id: "user:designer", role: "human" },
  action: { type: "create" },
  resourceType: "image",
});

// Generate the final image with all human inputs referenced
const { cid } = await pk.file(generatedImageBuffer, {
  entity: { id: "app:design-tool", role: "organization" },
  action: {
    type: "create",
    inputCids: [brief.cid, styleRef.cid],  // Both human inputs are referenced
    extensions: {
      "ext:ai@1.0.0": {
        provider: "stability",
        model: "stable-diffusion-3",
        autonomyLevel: "assistive",
      },
      "ext:license@1.0.0": {
        aiTraining: "reserved",
        hasAITrainingReservation: true,
      },
    },
  },
  resourceType: "image",
});

Querying Human Contribution

const graph = await pk.graph(outputCid, 5);

// Find all human-authored resources in the lineage
const humanInputs = graph.nodes.filter(n =>
  n.type === "resource" &&
  graph.edges.some(e =>
    e.to === n.id &&
    e.from &&
    graph.nodes.find(en => en.id === e.from)?.data?.role === "human"
  )
);

console.log(`${humanInputs.length} human-authored input(s) in provenance chain`);

// Find the autonomy level
const aiActions = graph.nodes.filter(n =>
  n.type === "action" && n.data?.["ext:ai@1.0.0"]
);
aiActions.forEach(a => {
  console.log("Autonomy:", a.data["ext:ai@1.0.0"]?.autonomyLevel);
});

Editing and Iteration Chains

Record the full editing workflow — each revision is a new resource with the previous as input:

// Draft 1
const draft1 = await pk.file(draft1Buffer, {
  entity: { id: "user:alice", role: "human" },
  action: { type: "create" },
});

// AI-assisted revision
const draft2 = await pk.file(draft2Buffer, {
  entity: { id: "user:alice", role: "human" },
  action: {
    type: "transform",
    inputCids: [draft1.cid],          // Previous draft is an input
    extensions: {
      "ext:ai@1.0.0": {
        provider: "anthropic",
        model: "claude-sonnet-4-6",
        autonomyLevel: "assistive",
      },
    },
  },
});

// Final human edit
const final = await pk.file(finalBuffer, {
  entity: { id: "user:alice", role: "human" },
  action: {
    type: "transform",
    inputCids: [draft2.cid],
  },
});
// The final work has a full provenance chain: create → AI-revise → human-edit

File Attachments as Inputs

When users attach existing files (images, documents) as inputs to an AI task, you need to record them in the provenance graph too. Two cases:

File already in the system (returned by pk.searchByFile) — reuse the existing CID as inputCid directly.
File not yet in the system — ask the user if they own it before recording:
- Owned → action.type = "create" → enters as a claimed resource
- Not owned → action.type = "reference" → enters as an unclaimed/external source

The FileProvenanceTag + FileOwnershipClaim UI components from @provenancekit/ui handle this flow automatically. See File Attribution & Ownership Claims for full implementation details.

Gotchas

Prompt privacy: Recording a prompt as a resource makes it content-addressed and potentially discoverable. If the prompt is sensitive, encrypt it with EncryptedFileStorage before uploading.
Autonomy level is asserted, not verified: The creator asserts the autonomy level. ProvenanceKit records the assertion — it doesn’t verify that the AI actually operated at that level. Trust is established through the consistency and completeness of the provenance graph.
Copyright is a legal determination: ProvenanceKit provides the data foundation. Whether a specific human contribution rises to the threshold of copyright protection is a legal question that depends on jurisdiction and the specific facts.

Legal & Compliance

Input Attribution

Human Creative Input & Copyright

Legal Context

The Core Insight

Recording the Pattern

What Gets Recorded

Autonomy Levels

Richer Creative Inputs

Querying Human Contribution

Editing and Iteration Chains

File Attachments as Inputs

Gotchas

​Legal Context

​The Core Insight

​Recording the Pattern

​What Gets Recorded

​Autonomy Levels

​Richer Creative Inputs

​Querying Human Contribution

​Editing and Iteration Chains

​File Attachments as Inputs

​Gotchas

Legal Context

The Core Insight

Recording the Pattern

What Gets Recorded

Autonomy Levels

Richer Creative Inputs

Querying Human Contribution

Editing and Iteration Chains

File Attachments as Inputs

Gotchas