Attribution has always been a cornerstone of working with other people’s creativity and knowledge.
As Creative Commons reminds us, practicing attribution serves many important functions, from providing verifiable evidence of a claim, to paying respect to the work of others, and creating pathways for traffic and financial value to flow.
Despite the importance of attribution, many of today’s AI systems fail to acknowledge the sources of knowledge and creativity that make them possible.
A recent study led by the AI Disclosures Project found that more than 30% of responses by leading search-enabled Large Language Models (LLMs) provided no attribution whatsoever. Even where attribution is provided, it can be limited in ways that are hidden to users, and deep technical challenges persist in connecting outputs from AI to the sources they are derived from.
Despite this, we believe there are good reasons to be optimistic that AI systems can attribute the sources they use. Not perfectly, and not always, but enough and improving, such that we should reject the argument that a lack of attribution is an inevitable side effect of the way the technology works. The commons needn’t become “hidden substrate.”
A Note on Terminology
In this post, we interpret attribution as the practice of connecting an artifact with the sources of data used to create it. This is deliberately broad. As we explain, it’s possible—and useful—for AI systems to practice different forms of attribution for different purposes. We are not referring to attribution as a specific legal requirement or condition. We also use “AI systems” broadly, as most of what we discuss applies to a wide range of models and surrounding technologies (although some methods apply mainly to systems that generate text outputs).
The first wave of LLM-based tools were essentially user interfaces that made calls to a static, pre-trained model (or “thin ChatGPT wrappers”). Outputs from these tools were a function of whatever the model had been exposed to in training, with no live access to sources.
This changed quickly. Now, architectures such as retrieval augmented generation (RAG) enable AI systems to draw on fresh data (such as web pages or a user’s files) to produce outputs.
This practice of retrieval makes AI systems much more amenable to attribution. When systems generate an output based on retrieved content, they can be trained and prompted to attach claims in the output to specific sources where those claims can be corroborated. This provides a form of credit, and allows users to follow through to web pages or trace back to their own files.
Claude, for example, can provide footnotes with clickable links to sources. To do this, it breaks the source materials it retrieves into “chunks”, each with a unique ID. Under default settings, it will—selectively, at least—cite the IDs of chunks that support the claims made in the output and render them as clickable links in the footnotes. Claude’s Citations feature can be used to make this practice more frequent and consistent, and enable outputs to point to exact passages from users’ files. It works by extracting source chunks, such as quotations, and injecting them, verbatim, into the output.
Other approaches exist. Pleias develops small, open-source AI models using openly licensed and public domain data. Pleias-RAG models are designed to produce outputs exclusively from retrieved sources. Rather than chunking and injecting, the model generates both the output and the supporting quote itself, in a single pass. This approach is more flexible, as the quote isn’t bound by pre-defined chunks, but it means that the system cannot fully guarantee that its quotations perfectly match the source. For a user, the result looks similar: an output whose claims trace to sources, with quoted excerpts and clickable links (if the application built on top of the open-source model makes this design choice).
There’s room for improvement here. Most AI systems do not attribute their retrieved sources as systematically as the Pleias-RAG models. Even where systems do, it often doesn’t amount to the full Title Author Source License (TASL) format that CC recommends. And frameworks like OpenMined’s Attribution-Based Control demonstrate how systems could practice a more decentralized, privacy-preserving form of retrieval, where data is queried where it lives rather than copied from the user’s system or the web into a central index.
In the round, retrieval architectures have enabled attribution practices that represent a strong improvement from the first LLM-enabled black boxes we were exposed to. These developments have led researchers from the AI Disclosures Project and their collaborators to conclude that “attribution gaps result from design choices, not simply technical limitations. The best-performing systems show that transparent, comprehensive attribution is technically feasible today”.
The approaches to attribution described above can provide corroboration, but they don’t truly establish that a listed source caused an output. They often list just one source, and only address the sources that a system accessed at inference time.
Using these methods, a system could rely on multiple sources to produce an output, across training and inference, but list only one source as corroboration.
Research is underway to address the harder question of: “given everything the system drew on, which sources shaped this output, such that removing them would have changed the result?”
Some methods attempt to answer this by reading the model’s internal state to estimate which inputs mattered to an output. Attention weights work by monitoring a model’s focus across retrieved source materials as it generates an output. The share of attention landing on a given source is sometimes used as a proxy for how much it mattered. Gradient-based methods instead measure sensitivity, seeking to calculate how much the answer would shift if each input were changed slightly, on the assumption that the inputs the output is most sensitive to are the ones that shaped it.
A different cluster of methods follows the logic of “leave one out” to try to identify how an output would change if one of its source materials was removed.
Doing this perfectly would involve rerunning inference with different sources withheld each time. That gets computationally expensive quickly, as attributing at the level of individual passages could mean hundreds of reruns per output. Most research attempts to approximate this effect by using different methods to cut the cost of producing the counterfactual. AttriBoT approximates the change in a system’s response when particular spans of retrieved sources are taken away by testing large blocks of source content first before “zooming in” on smaller spans. ContextCite looks at random subsets of the sources to predict how the answer shifts as sources are switched on and off. OpenMined is experimenting with Shapley values, which work by averaging each source’s marginal contribution across many different combinations of the sources.
This same counterfactual logic can also be pointed at training data rather than retrieved sources.
Influence functions estimate, without retraining, how sensitive the model’s output is to each training source and, therefore, how much removing one would change the answer. Doing this involves inverting a matrix that records how every parameter in a model interacts with every other parameter. Its size is the full model’s parameter count squared. For today’s models, which often exceed 3 trillion parameters, this is far too large to even store, let alone compute with. As a result, most progress on training data attribution involves producing estimations for which training data point’s absence would have changed the model’s output the most. Researchers at Anthropic have experimented with a technique called EK-FAC to approximate that enormous matrix with a simpler, structured stand-in. Arnoldi iteration keeps only the matrix’s dominant directions. Others cut the cost differently. TracIn skips the matrix and instead observes the model parameters at different points in training to assess how a particular input shaped the output, and TRAK treats the trained model as if it was a simple linear one, which makes the same estimate far cheaper to compute.
Researchers have found that estimates of training data contributions can be fairly accurate for small, simple models, but become unreliable quickly as models grow, and different methods are likely to disagree on the impact of a particular source. Also, while they can—perhaps—point to the individual training examples that most shaped an output, those examples are unlikely to have information about their authorship or provenance attached. Identifying an influential training source is not the same as being able to properly attribute it.
While imperfect, the methods described here are the product of a growing field of research dedicated to data attribution, and it’s reasonable to expect some will work their way into mainstream AI systems. Taking an even wider view, most of the systems we have today were not built to preserve information about the sources they use, especially in training. We are hopeful that more source-aware design choices will be made from the ground up (such as more curated and persistently identifiable training data), rather than attribution needing to be bolted onto systems that chose not to anticipate its importance.
Left to themselves, AI developers have disclosed little about the content their models are trained on or have access to. Many seem to view training data disclosure, in particular, as an unnecessary burden, or its composition as a source of competitive advantage and legal exposure.
In response, regulators have started to introduce minimum standards for what AI developers must document and publish about the data used by their models.
The EU AI Act, for example, requires providers of general-purpose AI models to publish a “sufficiently detailed summary” of their training content, using a template published by the European Commission’s AI Office. The template requires an organised account of the model’s main data sources, including large publicly available datasets, data licensed from rightsholders, and data crawled or scraped from online sources. California’s Generative AI Training Data Transparency Act similarly requires developers to publish a summary of the datasets used to train any generative AI system made available to Californians.
In this context, attribution involves connecting sources of training data to a model rather than to a specific output. It’s the difference between answering “what sources made this model capable of producing outputs?” vs “what sources has this model used to produce this output?” Answering this meets different needs to other forms of attribution described in this post, which are generally focused on connecting outputs from models to the sources used to generate them. Model-level attribution (often referred to as simply “transparency” or “disclosure”) enables consumers to compare competing systems, regulators to supervise and enforce regulation, and researchers to make high-order assessments of things like bias and safety.
This form of attribution is typically summarized rather than granular. Summaries might only individually name large—rather than all—publicly available datasets and other sources of training data. And it’s often practiced with carve-outs. The EU template, for instance, lets model providers redact some elements they can justify as trade secrets.
While they serve different purposes, we think it’s useful to see output-level and model-level attribution as related. First, the kind of source-aware design that model-level regulation increasingly encourages, such as the use of more curated training data, is also what makes better output-level attribution possible (as we discussed earlier in this post). Second, we expect regulators to evolve their demands of AI systems to include output-level attribution. In June 2026, the UK’s Competition and Markets Authority imposed a conduct requirement on Google, under which it must take steps to ensure its search content is attributed clearly and accurately, as well as publish user-friendly information explaining its attribution methods. (However, on that note, we should be wary of attribution regulations that are overly prescriptive, onerous, or impractical, especially for open source and non-commercial development of AI, or for machine use more broadly.)
After the first generation of LLMs became notorious for “hallucinations”, a system that outputs confidently without documenting its sources is now seen as deficient.
Users have come to expect to be able to click through to source material behind a claim, and that expectation shapes what gets built. It is part of the reason why systems like Claude now return outputs with links back to the web pages and user files that have been drawn on.
In regulated and sensitive markets, this expectation is hardening from a consumer preference into a procurement requirement. Buyers of AI systems in sectors such as law, medicine, and finance increasingly require auditable trails showing what a given output was based on, in order to satisfy their own compliance regimes. Designed for medical professionals, OpenEvidence attributes its sources through much the same approach as Claude, and further improves reliability by constraining those sources to vetted medical literature.
As individuals, enterprises, and governments push for “sovereign AI”, systems that behave as an opaque blender, indiscriminately mixing everything they can find, will not suffice. The architectural choices that make control of AI systems’ relationship with data possible—such as permissioned access, federated retrieval, and transparent retrieval logs—are the same ones that make for better attribution, especially at inference time.
There is pressure from the data supply side, too. While licensed data deals can be concerning to those of us with an interest in broadening the digital commons, they create commercial incentives and contractual obligations for AI firms to develop means of identifying which sources contributed to which outputs. ProRata uses attribution as the basis for licensing and payment (though their methods are unpublished, making it hard to tell what they are really doing or how accurate it is); Perplexity’s Comet Plus pays participating publishers when their content is visited, cited in an answer, or acted on by an agent; and Index by Parallel uses Shapley values to encourage writers to “see what [their] content is worth to AI agents.”
While traditional formats like TASL still have a role to play, especially at inference time, we should be open to new patterns and standards for presenting attribution information to users. For Shapley-enabled methods, OpenMined’s research shows how charts or other design features can present the relative contribution of several sources to a single synthesized output. The Wikimedia Attribution Framework describes how including reference counts, contributor activity and calls-to-action can support the credibility of AI-generated responses, and drive contributors and donations to sources. In scholarly settings, participants at a recent Cambridge workshop flagged the need for outputs to present information such as retractions and other expressions of concern.
We must not lose sight of the fact that attribution is a vital element of the social contract of sharing. Regardless of how machines are involved, naming our sources sustains the connection between a piece of creativity or knowledge and the people who produced it.
While it is indeed technically challenging, we’re optimistic that modern AI systems can meaningfully practice attribution, especially if attribution is incorporated by design. As this post has described: retrieval architectures make corroborative attribution eminently possible; more advanced, contributive methods are inching from research toward production; and commercial, regulatory, and user pressure are aligning behind the same goal.
As attribution practices mature, it’s important to us that they extend to creators, publishers, and stewards of openly licensed and public domain content rather than become the preserve only of those who engage in restrictive licensing deals or use sophisticated technology to gate access to their content.
Lastly, we shouldn’t lose sight of the fact that getting attribution right is necessary but insufficient for the future of the commons. A creator can be attributed and still lose the traffic that funded their work. A public library can still find itself overwhelmed by machines drawing on its collection en masse. A community like Wikipedia can still lose its connection with contributors, current and potential. To build a genuinely reciprocal relationship between AI and the commons, we also need bold new ideas, infrastructure, and forms of exchange to sustain the communities and institutions the commons depends on.
If you are working on attribution, especially building AI systems that practice it in some of the ways we describe here, CC would like to hear from you.
This article by Jack Hardinges and Irina Bejan (OpenMined) is licensed under CC BY 4.0. Thanks to Diyana Noory, Monica Granados, and Sarah Pearson at Creative Commons for their comments on a draft of this article.
Posted 24 July 2026
此内容由惯性聚合(RSS阅读器)自动聚合整理，仅供阅读参考。 原文来自 — 版权归原作者所有。