AI & your content

The single most-asked question of the whole platform is some version of "what will an AI do with my content?" This page answers it. The short version is that AI use is governed by the very same Contracts as everything else — nothing is fed to a model for any purpose unless a term on a governing contract permits it. There is no separate "AI mode", no platform-wide toggle, and no assumption that because content is on the platform it is fair game for a model. If a contract is silent about an AI use, that use is prohibited.

That matters because the platform enforces it, not merely promises it. The rights that say whether a model may read, cite, summarise, or train on a piece of content are resolved on the Work — the intellectual-property anchor — carried with every copy of the content, and checked by the platform at the point a model would use it: server-side, where an application cannot skip the check. Good intentions are not the safeguard; the mechanism is.

The reason there is a whole page for this — rather than a single "AI: yes/no" flag — is that "can an AI use this?" is really several very different questions. Using a book to fact-check a model's answer, to help an author draft the next chapter, to answer a reader who asks a question, to license the text to an outside AI company, or to train a model's weights are wholly different deals, and a rights holder routinely says yes to some and no to others. So the platform gives each AI action its own switch. This page walks through the six switches in plain English, shows how you turn each on or off, and explains how attribution and enforcement work.

The six AI verbs, in plain English

The platform names each AI action as its own usage verb, exactly the way it names each channel action (selling, hosting, lending) separately. Each verb is an independent switch on a contract, and each defaults to off until a term turns it on.

The verbs are independent, so a contract mixes them freely. The common shape for a cautious author agreement turns on AI_GROUNDING and AI_RETRIEVAL — verify my content, and cite it to readers — while leaving AI_TRAINING and AI_DISTRIBUTION off — never train on it, never license it to an outside model.

What AI can do with your content by default

Before you negotiate a single AI clause, a standard Packt author agreement already takes a position — and a deliberately narrow one. The default posture is first-party essentials on, everything else off:

• On: AI_GROUNDING and AI_RETRIEVAL, scoped to PLATFORM — that is, to Packt's own systems. Packt's assistant may check its answers against your book and cite your book to a reader, with credit. This is what makes the platform's own AI features work on your content out of the box.
• Off (by silence): everything else. No third party may retrieve your content, no model may be trained on it, and it may not be licensed onward to an outside AI — because no term grants those, and silence denies. First-party summarisation and writing-assistance are off too, until switched on.

So the honest one-line answer to "what will AI do with my book by default?" is: Packt's own assistant may consult it and quote it to readers, with credit — and nothing else, until you say so. The default open licences (MIT, Creative Commons) go further still and grant no AI terms at all: openly licensed material is not even first-party AI-enabled unless a bespoke term adds it.

How a rights holder controls it

Control is per contract and per verb. Because AI verbs are ordinary usage terms in the contract, turning an AI use on or off is the same act as any other rights grant: a term names the verb, gives it a verdict (PERMITTED, PROHIBITED, or CONDITIONAL), and optionally narrows it with the usual qualifiers.

Two ideas do most of the work.

Silence denies. If no term mentions a verb, that AI use is prohibited. There is no implicit permission — a Work never drifts into being trainable or licensable. Every AI permission is a deliberate, recorded grant on a specific contract. None of the platform's default licence contracts carry an AI_TRAINING term, so even openly licensed material is not trainable unless a bespoke term says so.

user_types decides first-party versus third-party. The who of an AI use lives on the term's user_types qualifier, not on the verb — one clause, one encoding. PLATFORM scopes a grant to Packt-operated systems (a first-party feature the platform itself runs); INDIVIDUAL / INSTITUTIONAL scope it to external consumers. So a grant that permits AI_TRAINING for PLATFORM only means Packt may train its own models, nobody else may — because no term covers anyone else, and silence denies.

The one exception is AI_DISTRIBUTION. "Onward to a third party" is built into that verb — exactly as it is for DISTRIBUTE with copies — so it does not need a user type to say "third-party". AI_DISTRIBUTION is the explicit switch for licensing your content to an external AI: if you want an outside AI company to use your content in their own system, this is the term that authorises it, and its absence is what keeps your content out of theirs.

[
  { "usage_type": "AI_GROUNDING", "status": "PERMITTED" },
  { "usage_type": "AI_RETRIEVAL", "status": "PERMITTED" },
  { "usage_type": "AI_TRAINING", "status": "PROHIBITED" },
  { "usage_type": "AI_DISTRIBUTION", "status": "PROHIBITED" }
]

{
  "usage_type": "AI_TRAINING",
  "status": "PERMITTED",
  "user_types": ["PLATFORM"],
  "source": { "document_id": "srcdoc_addendum_1", "clause": "2.1" }
}

{
  "usage_type": "AI_DISTRIBUTION",
  "status": "PERMITTED",
  "purpose": "COMMERCIAL",
  "source": { "document_id": "srcdoc_ai_partner_2026", "clause": "1.1" }
}

Changing a switch: self-serve or white-glove

Because an AI switch is an ordinary usage term, changing one is a contract amendment — a deliberate, recorded, versioned change, never a hidden flag. Packt offers two paths to make that change, and which fits depends on you:

• Self-serve (forthcoming). When the self-serve interface launches, you will be able to review every AI switch on your contracts and move the ones you are comfortable moving yourself; the platform records each change as a contract amendment, with the same provenance and versioning as any other term change.
• White-glove (today). Packt is a service partner, not a self-checkout. Your licensing contact can walk you through the options, model the commercial consequences, and make the change with you — the right path for a bespoke AI deal, a complex back-list, or simply when you would rather a person did it.

Which path you use varies by author — your familiarity with the terms, your history with Packt, and the nature of the change. Both land in the same place: a versioned amendment to the governing contract, after which the new switch is what the platform enforces. Either way transparency comes first — you can always see the current state of every AI switch on your Works, whichever path you use to change them.

What AI use costs

AI use is priced with the platform's ordinary commercial machinery — there is no separate AI meter and no special AI invoice. An AI use that earns money produces the same royalty events as any other use, in one of two familiar shapes:

• A served AI surface — an assistant answering readers under AI_RETRIEVAL, a metered summarisation feature — is treated as a consumption channel, so it settles the way a subscription does: the platform pools the surface's revenue, works out each Work's share of it for the period, and prices that share by the contract's rate rules. Reading through an AI assistant is metered like reading through a subscription.
• An AI deal — licensing your content to an outside AI company (AI_DISTRIBUTION) or a training arrangement (AI_TRAINING) — settles like a sale: either a fixed fee for the grant, or a revenue share of what the partner pays, whichever the deal specifies.

First-party grounding and writing-assistance, which serve nothing to a reader and earn nothing, normally carry no commercial term at all.

Two things follow from reusing the ordinary machinery. First, the money is private: AI commercial terms sit in the same scope-gated royalty block as every other rate, invisible to callers whose token may not see commercial terms. Second, the exact metric — how a pool is divided, what counts as a served answer — is platform policy owned by the royalty machinery, not a number frozen into your contract, so it can be tuned fairly without re-papering every agreement. This page states the shape of AI pricing; firm rates are set per deal.

How AI use is tracked

Pricing AI use as royalty events only works if the platform actually records, answer by answer, whose content each AI response drew on. It does — with one record per served response, called a usage event.

When an assistant or MCP tool answers a question, it typically pulls back somewhere between five and fifty passages from the Content Lake and composes its answer from them. The platform does not log fifty separate reads; it logs one usage event for the whole answer, listing every passage the answer used — which Resource and exact version, which Work it belongs to (and so which contract and payees), whether the passage was shown to the reader or only consulted invisibly, whether it was credited, and the precise contract versions the use was authorised under. That single record is what feeds three things:

• Royalty attribution. When a consumption pool is divided for a period, the usage events are the ledger of which Works earned a share of it — the 37-passage answer contributes to 12 Works' shares, in proportion the royalty machinery computes from the recorded facts.
• Rights carriage. Each entry pins the contract versions in force at the moment of serving, so any later question — "was this use actually permitted?" — replays against exactly the terms that applied, not today's.
• Your reporting. "How often is my book being used by the assistant, and was it credited?" is a query over these events.

Two boundaries keep the model honest. First, the AI surface itself is an ordinary Product in a Packt-operated channel, so consumption attributes to it the way subscription reads attribute to a subscription — no special AI plumbing. Second, a usage event is a record of consumption, not of creation: if an answer (or an email your team drafted with AI assistance) never becomes stored content, the usage event is its complete record. Only when someone saves that output into the platform does the provenance system take over, recording an Activity that names the same source content the usage event logged — consumption and lineage meet exactly at that point.

Attribution travels with retrieval

When content is surfaced to a reader by an AI — the AI_RETRIEVAL case — the credit obligation travels with it. Attribution is not a property of the AI feature; it is a handling term on the contract, and a handling term applies to every use of the content, AI included. So if a Work's contract requires ATTRIBUTION, an AI answer that quotes or cites the content must carry that credit, just as a printed excerpt would. The obligation is resolved and carried alongside the content, so the surface that shows the passage also knows who to credit. See the contract model for how handling terms are defined and resolved.

How the platform enforces it

The verbs would be worth little if an application could simply ignore them, so the check runs where an application cannot reach around it. On consequential AI surfaces — a retrieval endpoint, an assistant, a distribution pipeline — the platform resolves the relevant AI verb for the content and applies it server-side, before the content is ever handed to a model.

flowchart LR
    Q["AI request<br/>(e.g. answer a reader)"] --> R["Resolve the AI verb<br/>for this content<br/>(e.g. AI_RETRIEVAL)"]
    R --> D{"Permitted for<br/>this use & caller?"}
    D -->|yes| U["Content used by the model<br/>attribution carried with it"]
    D -->|no| B["Blocked<br/>content never reaches the model"]

This is most visible in Search, which is how AI assistants find the right passage. A retrieval query can ask only for content whose resolved rights permit AI_RETRIEVAL, and on consequential surfaces that rights predicate is enforced by the platform regardless of what the caller requested — content whose rights prohibit the use is filtered out server-side and never reaches the model. Rights are held once on the Work, cached on every Resource, and revalidated at the moment of use; the AI check is that point-of-use check.

Related pages

• The contract model — the technical reference for the AI verbs, the qualifier set, and how rights resolve and merge.
• Royalties & commercial terms — how AI use is priced: the royalty events, basis, and the privacy of commercial terms.
• Contracts & Rights — how contracts sit at the centre of the platform and govern every use of content.
• Search — where the retrieval rights check is applied server-side on AI surfaces.
• Explorer — Chapter III — contracts and rights, visualised.