StrictCite: A Deterministic Citation Verification Tool That Uses Zero AI — Say Goodbye to LLM Hallucinated References

When LLMs Start Fabricating Citations

As generative AI becomes increasingly common in academic writing, a thorny problem has emerged: large language models don't just confidently make up facts — they fabricate references that don't exist, complete with invalid or entirely fake DOIs (Digital Object Identifiers). For researchers, a seemingly well-formatted reference list may be hiding a host of hallucinated citations.

A computer engineering undergraduate student (who also researches LLM inference bottlenecks) shared his solution on Reddit. His motivation was straightforward: "I got tired of LLMs hallucinating citations, so I built a fully deterministic parser that uses zero AI." That tool is StrictCite.

Why Not Use AI to Check AI?

There's a design philosophy worth unpacking here. The developer specifically emphasized that he deliberately avoided using LLMs for verification. The reason is simple: if you use a hallucination-prone model to validate another model's output, the verification step itself can be contaminated — "LLMs will just hallucinate the verification results too."

This observation cuts to the heart of a core problem with many AI-assisted research tools. Most so-called "AI fact-checkers" are, at their core, just another round of sampling from a probabilistic model — incapable of providing reliable, deterministic guarantees.

How StrictCite Works: Technical Approach

A Deterministic Engine With Zero Generative AI Components

StrictCite's core is a deterministic engine that contains absolutely no generative AI components. Its workflow is as follows:

• Parses the user's .bib file (BibTeX format) locally in the browser;
• Makes hard API cross-references against 13 academic registries including Crossref and DBLP;
• Flags missing DOIs, fabricated conference names, and fake journal venues.

"Deterministic" means the same input always produces the same output — results are reproducible and traceable. This stands in sharp contrast to LLMs, whose probabilistic nature means responses can vary each time. For scenarios demanding high academic rigor, this predictability is critical.

Honest Disclosure of Strengths and Limitations

The developer is refreshingly candid about the tool's capabilities and boundaries.

Where it excels: On its test set, StrictCite perfectly catches completely fabricated references. For citations that were simply invented from thin air and don't exist at all, the tool's detection rate is excellent.

Where false positives occur: It generates false positives for minor discrepancies between preprints and formally published versions. When a paper exists both as an arXiv preprint and a journal publication, the tool may incorrectly flag it as suspicious due to version mismatches. This is a classic "false positive" issue — the tool errs on the side of caution, preferring over-reporting to missing anything.

Edge Cases Worth Watching

The developer actively invited the community to stress-test the tool with "messy citations," specifically calling out several challenging edge cases:

• Old books — publications from decades ago lacking standardized metadata;
• Translated Russian monographs — cross-language, cross-script documents;
• 2003 conference proceedings — records from the early, incomplete era of digitization.

These are precisely the scenarios where automated verification systems are most likely to fail. Older publications often lack DOIs, and cross-language documents have inconsistent coverage across registries. Testing against these "hard cases" gives a realistic picture of the tool's usability in actual research workflows.

An Industry Signal: The Rise of Academic Integrity Infrastructure

Deterministic Verification Infrastructure Is Emerging

StrictCite is still an early-stage project (offering a limited free tier and a time-limited testing channel), but it reflects a crystallizing need: in the age of AI-assisted writing, we need an independent, trustworthy layer of verification infrastructure.

Generative AI has dramatically boosted writing productivity, but it has also transferred the burden of credibility verification onto readers and reviewers. Deterministic tools like StrictCite are essentially using traditional, auditable software engineering methods to combat the uncertainty of probabilistic models — a philosophy of fighting uncertainty with certainty.

Practical Advice for Researchers Using AI-Assisted Writing

For researchers using tools like ChatGPT or Claude to assist with literature reviews, here are some practical takeaways:

1. Never trust citations generated directly by AI, especially DOIs and specific page numbers;
2. Use deterministic tools (like StrictCite) for verification — don't just run the output through another LLM;
3. For old, cross-language, or non-mainstream sources, manual verification is still necessary, as automated tools are least reliable at these edges.

Ultimately, AI can help us write — but the question of whether a given paper actually exists is best answered by a deterministic engine that doesn't know how to lie.