# Declare AI use and provenance

> Say on your listing what your plugin or sound pack generates with AI, which models and datasets it uses, how much of what it ships is synthetic, who holds the rights and whether others may train on your work. Every field, the task list, and how to turn the declaration into a C2PA manifest.

Canonical: https://maru.audio/docs/provenance
Documentation index: https://maru.audio/llms.txt

Your listing can say exactly how your plugin or sound pack uses AI to make audio or MIDI. Listeners see it on your page under **AI and provenance**, each dataset you name links back to your page, and the same facts can travel inside the files you ship as a C2PA manifest.

You declare what the product *makes*, not how you built it. If you wrote the code or designed the interface with an AI assistant, there is nothing to declare.

## What to declare

| Your product | Declare it? |
| --- | --- |
| Generates audio with a trained model (text to audio, one-shots, latent synthesis, voices) | Required |
| Changes audio you give it with a trained model (continuation, timbre transfer, voice conversion) | Required |
| Generates MIDI with a trained model, or from patterns learned from a dataset | Required |
| Ships samples, kits, loops, presets or MIDI that a model generated | Required |
| Separates stems with a model | Recommended |
| Generates MIDI from rules and randomness you wrote, such as a Euclidean sequencer | Optional |
| Models an amp or effect with a trained network | Optional |
| Was written or designed with help from AI | Not declared |

When you don't add a declaration, your page says **Not declared**. It never says "No AI".

## Add it to your listing

Add a `provenance` block to the entry in `.maru/listing.json`:

```json
{
  "format": "maru-listing/v1",
  "listings": [
    {
      "family": "plugins",
      "slug": "melody-bot",
      "kind": "midi-tool",
      "provenance": {
        "format": "maru-provenance/v1",
        "generation": [
          {
            "task": "melody-generation",
            "basis": "trained-model",
            "models": [{ "id": "midi-gpt/yellow_small", "label": "MIDI-GPT Yellow Small" }],
            "datasets": [{ "address": "@colinraffel/lakh-midi", "use": "training" }]
          },
          { "task": "drum-pattern-generation", "basis": "rules", "note": "Euclidean and probability steps." }
        ],
        "rights": { "copyright": "© 2026 Example Audio" },
        "trainingPermission": { "aiTraining": "notAllowed", "dataMining": "allowed" }
      }
    }
  ]
}
```

Then check it:

```bash
maru provenance check
```

The check prints each fact your page will show, most important first. If anything in the block is wrong, Maru leaves the whole block out rather than show half a declaration, and `maru listing check` reports why.

## Fields

| Field | What it holds |
| --- | --- |
| `format` | Always `maru-provenance/v1` |
| `generation` | What your product does while it runs. Each entry has a `task`, a `basis`, and optional `models`, `datasets`, `userModels` and a one-sentence `note` |
| `content` | What you ship. Each entry has a `kind` (`samples`, `loops`, `kits`, `presets`, `midi`, `impulse-responses`, `wavetables`, `models`), how much is `synthetic` (`none`, `some`, `most`, `all`), an optional `percent`, and optional `task`, `basis`, `models`, `datasets` and `derivedFrom` |
| `rights` | A `copyright` line, and `holders` with a `name`, a `role` (`code`, `content`, `models` or `datasets`) and an optional HTTPS `url` |
| `trainingPermission` | Whether others may use your work for `aiTraining`, `aiGenerativeTraining`, `aiInference` and `dataMining`: `allowed`, `notAllowed` or `constrained`. With `constrained`, add a `constraint` sentence |

**Basis** says how the output is made: `trained-model`, `corpus-statistics` (no neural network, but patterns, transitions or fragments learned from a dataset), or `rules` (procedures and randomness you wrote).

**Models** take one of: `id` (a Maru model source such as `basic-pitch/nmp-onnx`), `address` (a model page such as `@stabilityai/stable-audio-3-small`) or an HTTPS `url`, plus an optional `label` and `license`. Set `userModels: true` when people can load their own weights.

**Datasets** take an `address` from the [dataset catalog](https://maru.audio/datasets), such as `@google/maestro`, or an HTTPS `url` with a `label`, and a `use`: `training`, `fine-tuning`, `corpus`, `conditioning` or `evaluation`. Every dataset page has a **Rights and provenance** view with the exact address to copy, and a **Used by** view that lists the listings naming it.

**Shipped material derived from a recording** names it in `derivedFrom` with a `title`, optional `artist` and `url`, and a required `license`. A kit seeded from a CC BY-SA song carries that song's terms.

`some` means under half of the material, `most` means half or more but not all. A `percent`, when you give one, has to agree.

## Tasks

Pick the task that says what happened to the sound. Run `maru provenance tasks` for the full list with the level each basis carries.

| Audio, new | Audio, from yours | MIDI |
| --- | --- | --- |
| `text-to-audio`, `text-to-music`, `unconditional-audio`, `one-shot-generation`, `latent-synthesis`, `voice-synthesis`, `midi-to-audio`, `stem-generation` | `audio-continuation`, `audio-inpainting`, `audio-to-audio`, `timbre-transfer`, `voice-conversion`, `neural-resynthesis`, `stem-separation`, `neural-effect` | `melody-generation`, `drum-pattern-generation`, `chord-generation`, `text-to-midi`, `harmonization`, `accompaniment`, `midi-continuation`, `midi-inpainting`, `audio-to-midi` |

## C2PA manifests

C2PA is the open standard for content credentials: signed statements, attached to a file, about how it was made. Maru turns your declaration into a C2PA manifest definition you can sign and attach with any C2PA tool.

```bash
# For your release archive
maru provenance c2pa --slug melody-bot --title melody-bot-1.0.zip --out release.c2pa.json

# For one file your plugin generated
maru provenance c2pa --slug melody-bot --task melody-generation --basis trained-model --title riff.mid --out riff.c2pa.json

# Sign and embed with the C2PA reference tool (WAV, AIFF, MP3, M4A)
c2patool render.wav -m manifest.json -o render-signed.wav
```

The manifest marks generated files with the IPTC digital source type C2PA readers understand (for example `trainedAlgorithmicMedia`), lists your models and datasets as ingredients, carries your training terms as a `cawg.training-mining` assertion, and includes your whole declaration. MIDI files take the manifest as a `.c2pa` file beside them. The definition is unsigned; signing needs your own certificate.

## What Maru does and doesn't check

Your declaration is shown as yours: "Declared by the maker". Maru checks its shape and that dataset and model references are well formed. Licenses and dataset sourcing on dataset pages are our reading of each publisher's description, not legal advice.
