Is there an AI that doesn't make up references?

The short answer is yes. If you searched this after a chatbot handed you a beautifully formatted reference to a paper that turned out not to exist, you are asking exactly the right question, and there is a real answer that does not depend on hoping the next model version behaves better than the last one did.

But the answer is not a smarter model or a sterner prompt. It is a different design: one in which a reference is not text the AI writes but an object that must resolve to a real paper before you can see it. This guide explains why most tools cannot make the promise, what the promise has to cover to be worth anything, how to test any vendor's claim for yourself (including this one), and what actually changes in your day-to-day writing when fabrication is off the table.

How big is the problem in 2026?

Bigger, and better measured, than when this question first started trending. Three data points from the past year set the scale. First, an independent audit of AI research assistants (the DeepTRACE benchmark) measured a leading deep-research assistant at roughly 79% citation accuracy, meaning about one in five of the sources it cited did not support the sentence they were attached to. That is the metric's whole point: it judges whether the cited source backs the claim, a failure that survives every existence check because a source can be perfectly real and still say something else.

Second, the problem has reached the published record itself. An audit reported in The Lancet found the rate of fabricated citations in published papers rose from roughly one in 2,800 papers in 2023 to about one in 280 by early 2026, roughly a tenfold rise in under three years. Peer review is catching some of it; clearly not all of it.

Third, the stakes stopped being hypothetical. In Kohls v. Ellison, a United States federal court threw out an expert declaration after opposing counsel found it cited articles that did not exist; the expert had drafted with AI assistance and not verified the references. If it can happen to a professional expert in a filing read by adversarial lawyers, it can happen in a thesis chapter read by an examiner who knows the literature better than you do.

Why most AI tools make up references

In a general AI tool, a citation is free text: the model predicts a plausible author, year and title the same way it predicts any other words. A reference list is one of the most regular text patterns in academic writing, so the model reproduces its shape flawlessly whether or not any specific paper stands behind it. That is why 'please only use real sources' never fully works. The instruction changes the wording, not the mechanism, because the model has no way to tell a reference it genuinely absorbed from one it is assembling on the fly. Both come out of the same next-word machinery with the same confidence.

As long as references are generated as text, some of them will be invented, and the convincing format is exactly what makes them dangerous: a fabricated reference does not look fabricated. For the full mechanism, including the five distinct failure modes from fully invented papers down to real papers cited for claims they never make, read Why AI makes up citations, and the fix. The point that matters here is that no amount of prompting closes the hole. Only a different design does.

Tools with web browsing or retrieval do better on average, and it would be unfair to pretend otherwise: a fetched source can anchor a reference to something real. But the final step is still the model writing the reference down as text, and text can always be invented, transposed, or mismatched. Reduction is not impossibility, and a thesis, where a single phantom reference in front of an examiner can undo years of work, is a context where that difference is the whole game.

What 'doesn't make up references' has to mean

Before trusting any tool's promise, pin down what the promise must cover. A guarantee worth the name has three parts, and most tools that advertise 'real citations' deliver at most the first:

• Every reference resolves. Each citation corresponds to a specific, findable record of a real paper: an identifier you can look up, not a plausible-looking string.
• Every claim matches its source. The cited paper actually supports the sentence it is attached to, judged against the paper's text rather than the model's memory of it.
• There is a record. You can show afterwards which claims were checked, when, and with what verdict, because a check you cannot demonstrate might as well not have happened.

Why all three guarantees matter

Miss the second part and you get genuine papers cited for things they never said, which is the failure that survives every existence check and the one examiners are best placed to catch, because they know the literature. Miss the third and you cannot defend any of it later: when a supervisor asks how you know a claim holds, 'I checked at some point' is a much weaker answer than a recorded verdict with a date. Hold every tool you evaluate, including this one, to all three parts.

This framing also explains why the question 'is there an AI that cites real papers?' is subtly incomplete. Citing real papers is the easy third of the problem. The hard parts are matching claims to sources and being able to prove it, and a tool designed only for the easy third will look trustworthy right up until someone reads a cited passage.

The by-construction fix: citations that must resolve to real papers

CiteDash AI removes the possibility rather than discouraging it. A citation here is not text a model writes. It is a database row that must resolve to a real paper record, and if a generated citation does not resolve, it is rejected before it can reach you. There is no free-text reference anywhere in the product. A made-up reference does not get caught after the fact; it has nowhere to exist in the first place.

That is the difference between a tool that tries not to fabricate and one that structurally cannot. A prompt is a request; a data model is a constraint. When the system has no representation for a reference that is merely text, honesty stops being behaviour the model has to remember under pressure and becomes the only thing the system can express. You do not audit for a failure the design cannot produce, any more than you proofread a spreadsheet for handwriting errors.

The object design pays off downstream as well. Because a citation is a record rather than a string, your bibliography is derived from the same objects: the Reference Manager renders them in any of twelve citation styles, and the Thesis Assembler compiles them into DOCX, PDF or LaTeX with a citeproc bibliography. Switching styles is a re-render rather than an evening of retyping, and a reference can never drift out of sync with the paper it points to, because there is only one object behind both.

Citing a real paper is not enough: the claim must match the source

A reference that resolves is necessary but not sufficient. The quieter failure is a genuine paper cited for a claim it never makes, and it is the one existence checks cannot catch. So CiteDash checks each cited sentence against the cited paper's stored full text, not its abstract and never the model's memory, and labels it supported, partial, unsupported, or unverified before it reaches you. A claim it cannot ground in real full text comes back honestly unverified rather than dressed up as fact.

The verdicts are designed to be acted on. A partial usually means you overclaimed and a qualifier fixes it. An unsupported means rewrite the sentence, cite a different source, or delete the claim. An unverified means the system has nothing to read yet: add the paper's PDF to your Library and re-verify. For each verdict and its fastest fix, read How verified citations work: the four verdicts.

The honest verdict matters more than it first appears. When the full text is not held, the system does not guess; it says unverified and waits. A tool that always sounds certain is concealing its gaps. One that can say 'not checked yet' is telling you exactly where your remaining risk lives, which is what you actually need to know in the week before submission.

A worked example: trying to force a fake reference

The cleanest way to understand the design is to try to break it. Against a chatbot, the attack is easy: pick a genuinely thin topic, ask for sources, and keep pushing when the first answers are vague. Sooner or later the model obliges with references that shade from real into fictional, because producing a plausible reference is easier for it than admitting it has nothing. The thinner the literature, the sooner it happens, which is exactly backwards from what a researcher needs.

Run the same attack in CiteDash and there is no path for it to succeed. Ask the Thesis Editor for a paragraph and it drafts only from the full text of papers in your project library, so the AI cannot cite a paper it has not read. Push into territory your library does not cover and you do not get an invented source; you get prose flagged as unsupported, in place, where you can see it and decide what to do. Ask the Literature Finder for sources and it searches an internal corpus plus live OpenAlex, PubMed, Semantic Scholar and arXiv, so what comes back are real records with real identifiers, because that is all a search over real databases can return.

The failure a chatbot hides, that the evidence does not exist or that you do not yet hold it, becomes visible information: a gap in your library to fill or a claim to soften. That is the practical meaning of 'doesn't make up references'. Not a model on its best behaviour, but a system in which the dishonest output has no representation.

How to test any AI tool's citation claims yourself

Do not take a vendor's word for any of this, including ours. Here is a test protocol you can run against any AI writing tool in under an hour; the free DOI lookup makes the resolution steps quick:

• Ask for a short paragraph with three citations on a niche topic in your own field, then look each reference up. Anything you cannot find in a scholarly database is fabricated.
• Repeat on a topic you know is thin. Sparse literatures are where fabrication spikes, because the model has learned the format far better than the field.
• Take one real citation it produced and read the cited passage. A resolvable reference attached to a claim the paper never makes is still a failure, and it is the failure existence checks miss.
• Ask what happens when it cannot support a claim. The right answer is that it tells you so; a tool that always sounds certain is hiding the gaps.
• Revise a cited sentence and see whether anything re-checks it. Claims drift during editing, and a verification that ran once and never again is a snapshot, not a guarantee.
• Check whether it keeps a record. If you cannot show what the AI did and where each claim came from, you cannot defend the work later.

Four common designs and what each one risks

Most tools you will evaluate fall into one of four designs, each with a characteristic risk profile when judged against the three-part guarantee above. If a vendor cannot tell you plainly which of these they run, the test protocol in the previous section will tell you within the hour:

• Pure chatbot: references are free text from the model's memory. Every failure mode is open, from invented papers to mismatched claims. Fine for brainstorming; unusable as a source of bibliography entries.
• Chatbot with browsing: fetched pages anchor some references, so outright inventions drop. The reference is still written out as text, and nothing ties the sentence it supports to what the source actually says.
• Retrieval tools grounded on abstracts: citations point at real records, which is genuine progress, but an abstract is a compressed pitch. A claim can be consistent with the abstract and contradicted by the paper's own results section.
• Database-object citations with full-text verification: references must resolve or they are rejected, and every cited sentence carries a verdict from the paper's body text. Fabrication is impossible rather than discouraged. This is the CiteDash design.

Objections and answers

'Newer models rarely hallucinate references now.' Rarely is not never, and a thesis is a zero-tolerance context: one fabricated reference found by an examiner is not offset by two hundred good ones. A design guarantee does not depend on the model having a good day, and it is the only kind of promise that survives a model upgrade, a provider change, or an unlucky prompt.

'I will just check every reference myself.' Existence checks are the easy half, and even they take real hours across a full bibliography, repeated after every revision round. The hard half is claim-source matching, which means re-reading the cited passage every time a sentence changes. That is precisely the labour verification automates, with a verdict recorded each time so the work is demonstrable rather than remembered.

'What about papers whose full text I do not have?' Then the honest state is unverified, and that is exactly what the system reports. Upload the PDF to your Library, or fetch the paper's details from its DOI, and re-verify. The point is not that every claim is instantly green; it is that missing evidence shows up as missing instead of being papered over by a confident-sounding sentence.

'Doesn't all this verification slow drafting down?' It moves the checking to the moment it is cheapest. Seeing a verdict on a sentence as you draft costs seconds; discovering a mismatched citation during final read-through costs an afternoon; having an examiner discover it costs far more. Front-loading the check is the time-saving option, not the slow one.

What you get when fabricated references are impossible

Put the pieces together and the day-to-day experience changes in concrete ways. None of it depends on you remembering to be careful at midnight before a deadline:

• Drafts are generated only from full text in your own library, so the AI cannot cite a paper it has not read.
• Every citation provably resolves to a real paper; unsupported prose is flagged in place, never hidden.
• Every cited sentence carries a verdict against its source's full text: supported, partial, unsupported, or unverified.
• Retracted papers are badged in the Library and blocked from citation, and an originality pre-check runs before you compile.
• A complete audit trail generates the AI-use disclosure your institution may ask for.

Free reference checks you can run right now

You do not need an account to start applying the standard today. Paste any suspect DOI into the DOI lookup mentioned above and see what it actually resolves to: nothing, a different paper, or the claimed one. Run any paper you are about to lean on through the free retraction checker, because a citation to a withdrawn paper is a failure no formatting can fix. And when you need a correctly formatted reference for a paper you have already verified, the site's free citation generators cover twelve styles, from APA and Harvard to IEEE, Vancouver and Chicago. If you cite as you verify, the formatting stage stops being a chore at the end and becomes a byproduct of checking.

When you want to test the full system rather than one reference at a time, the fastest way to believe a 'no fake references' claim is to try to break it. Start free with the signup credit grant (no card required), or explore the demo without an account, then open any generated citation to its exact source passage and watch the verdict respond when you edit the sentence it supports.

A reference list assembled this way is not a liability you hope survives scrutiny. It is evidence you can hand an examiner: one resolvable, verified object at a time, with a record behind each one.