# AI limitations in understanding: where models fall short and why it matters

> AI models predict plausible text without a reliable model of the world. See where their understanding falls short and how to use them safely in critical work.

- URL: https://computese.com/ai-limitations-in-understanding/
- Author: Duong Quan Nguyen, CEO, Computese
- Published: 2024-11-08
- Updated: 2026-09-25
- Topics: AI & automation

## In short
- Large language models predict likely text from patterns in their training data. They do not hold a reliable model of the world, so fluent, confident answers can still be wrong.
- In a 2024 study reported by MIT, a model that gave near-perfect New York directions had learned an impossible map, and its valid routes fell from 99% to 69% when detours were forced at 1% of steps.
- Apple's GSM-Symbolic study found that one irrelevant sentence cut math accuracy sharply for every model tested. New numbers, prompt formatting and the way a question is framed shift answers too.
- Critical uses need checks outside the model: answers drawn from approved sources, evaluation on real and changed cases, and a person who can override, organized with the NIST AI RMF.

AI systems such as large language models do not understand the world the way their fluent answers suggest. They predict likely text from patterns in their training data, so they can state falsehoods with confidence, fail when a familiar problem changes slightly, and answer the same question differently when it is reworded. Critical uses need checks around the model.

The limits are well documented. In November 2024, MIT News reported a study showing that a model can give near-perfect driving directions in New York City without an accurate map of the city. This guide explains that study, the other documented limits of AI understanding (hallucinations, brittle reasoning, missing grounding and memory, sensitivity to wording), why they matter most in critical applications, and what good practice looks like. How these models generate their answers in the first place is explained in [what generative AI is](https://computese.com/the-rise-of-generative-ai/).

## What the MIT study on AI understanding found

On November 5, 2024, [MIT News](https://news.mit.edu/2024/generative-ai-lacks-coherent-world-understanding-1105) reported on "Evaluating the World Model Implicit in a Generative Model", a paper by Keyon Vafa, Justin Y. Chen, Ashesh Rambachan, Jon Kleinberg and Sendhil Mullainathan of Harvard, MIT and Cornell, presented at the NeurIPS conference. The [paper](https://arxiv.org/abs/2406.03689) asks a simple question: when a transformer, the architecture behind large language models, predicts sequences very well, has it learned the rules of the world that produced them?

The researchers trained transformers from scratch on turn-by-turn directions built from New York City taxi rides in Manhattan. By the usual tests, the models looked excellent: the next turn they predicted was valid nearly every time, and they usually found the shortest path between two intersections. Two new tests, which check whether a model treats identical situations alike and different situations differently, told another story. When the team reconstructed the street map each model implied, it contained streets with physically impossible orientations and flyovers above other streets.

That incoherence showed up as fragility. When the researchers forced a random detour at 1% of the steps, the share of valid routes from the model trained on shortest paths fell from 99% to 69%. At 10% it fell to 8%. A model trained on random walks, which had seen far more varied routes, held up much better and also scored far better on the new tests.

![A street grid seen from above. A car's route reaches an orange barrier, and the detour curves across city blocks where no street exists, over a diagonal flyover, to an orange pin.](https://computese.com/images/blog/ai-limitations-in-understanding/detour.15d837cf31-1536.webp)

*Near-perfect directions on familiar routes hid a map with streets that do not exist, and detours exposed it.*

The same pattern appeared outside maps. In seating-arrangement logic puzzles, GPT-4 solved every fully specified puzzle, yet all the large language models tested did poorly on the consistency checks: more than half the time, two descriptions that left exactly the same seating options open were treated as different situations. Good task scores did not mean the model held the rules.

> [!NOTE]
> The navigation models were GPT-2-style transformers trained from scratch on route data, not chatbots. The finding is about what high accuracy proves: a model can be right on the cases it was measured on without having learned the structure that would keep it right when conditions change.

## Why fluent answers are not the same as understanding

A large language model (LLM) is trained to predict the next token, a word or part of a word, across enormous amounts of text. The result is nearly always fluent and often correct. NIST's Generative AI Profile ([NIST AI 600-1](https://www.nist.gov/publications/artificial-intelligence-risk-management-framework-generative-artificial-intelligence), July 2024) calls false output a natural result of this design: a model that approximates the statistical distribution of its training data can produce accurate, consistent answers, and it can also produce answers that are inaccurate or contradict themselves.

Three ideas describe what is missing:

- **A world model.** An internal representation of how the domain works, its states and rules, that carries a system through cases it has not seen. The MIT study shows that you cannot infer one from good predictions alone.
- **Grounding.** A link between words and the things they refer to. In a 1990 paper, Stevan Harnad called this the [symbol grounding problem](https://arxiv.org/abs/cs/9906002) and compared a system that knows symbols only through other symbols to someone trying to learn Chinese from a Chinese-only dictionary.
- **Calibration.** Whether confidence matches accuracy. Generated text reads equally sure whether it is right or wrong. How chatbots signal uncertainty, or fail to, is covered in [human-like AI and confidence](https://computese.com/ai-advancements-bridging-the-gap-between-human-like/).

The research question is still open. In the same paper, an Othello model trained on synthetic games passed both world-model tests, while one trained on championship games did not, so some models do build coherent internal structure. For anyone deploying AI, though, the practical conclusion is settled: understanding cannot be assumed from fluency, and not from a benchmark score either. Our explainer on [Google Gemini and its MMMU score](https://computese.com/google-unveils-gemini-the-most-advanced-and-versatile-ai-model-yet/) covers what benchmark results do and do not tell you.

## Hallucinations: confident answers that are wrong

A hallucination is output that is plausible but false or unsupported: an invented citation, a wrong date, a refund policy that does not exist. NIST AI 600-1 uses the term confabulation for confidently stated but erroneous or false content, and warns that models can also produce confabulated logic or citations that make a wrong answer look justified.

A September 2025 paper by researchers at OpenAI and Georgia Tech, [Why Language Models Hallucinate](https://arxiv.org/abs/2509.04664), traces the problem to two causes:

1. **Pretraining.** Some facts follow no pattern a model can learn. A fact that appears only once in the training data, such as an obscure person's birthday, is essentially a guess, and the paper ties the minimum hallucination rate after pretraining to the share of such one-off facts. Asked three times for the lead author's birthday, a state-of-the-art open model gave three different wrong dates.
2. **Evaluation.** Most benchmarks grade answers as right or wrong and give no credit for "I don't know". A model tuned to score well learns that a confident guess beats an honest abstention.

Two other results frame the problem. A 2024 theoretical paper by [Xu, Jain and Kankanhalli](https://arxiv.org/abs/2401.11817) argues that hallucination cannot be completely eliminated in LLMs used as general problem solvers. Detection is possible for some cases: a method published in [Nature in June 2024](https://www.nature.com/articles/s41586-024-07421-0) samples several answers to the same question, groups them by meaning, and flags a likely confabulation when the meanings disagree, a measure its authors call semantic entropy.

In software, the same failure shows up as code that imports packages that do not exist, a supply chain risk covered in our [secure coding guide](https://computese.com/best-practices-for-secure-coding/).

## Brittle reasoning when a problem is reworded

GSM8K is a widely used benchmark of grade-school math word problems, and model scores on it had risen sharply in recent years. In October 2024, Apple researchers published [GSM-Symbolic](https://machinelearning.apple.com/research/gsm-symbolic) to test whether those scores reflected reasoning. They turned 100 GSM8K problems into templates and generated 50 versions of each, changing names and numbers but not the steps needed to solve them. The [full paper](https://arxiv.org/abs/2410.05229) reports that:

- **Accuracy moved when only names and numbers changed.** Across the 50 sets, the gap between a model's best and worst score was more than 12 points for Gemma2-9B and about 15 for Phi-3.5-mini. Changing only the numbers lowered every model's accuracy; changing only the names hurt much less.
- **Each added clause cost accuracy.** Performance dropped and varied more as problems gained one or two extra conditions.
- **One irrelevant sentence caused the largest drops.** In a variant called GSM-NoOp, each problem gains a clause that sounds relevant but changes nothing. In one example, a problem about picking kiwis over three days mentions that five of Sunday's kiwis were a bit smaller than average, and the models, o1-mini included, subtracted them.

| Model (8-shot)             | GSM8K | GSM-NoOp, one irrelevant clause added |
| -------------------------- | ----- | ------------------------------------- |
| GPT-4o                     | 95.2% | 63.1%                                 |
| o1-preview                 | 94.9% | 77.4%                                 |
| Phi-3-mini (128k instruct) | 83.7% | 18.0%                                 |

![A word problem drawn as grey bars feeds a gear. One orange bar, an irrelevant detail, is pulled into the gear too, and the answer comes out with a cross. A faded run above, without that bar, ends in a check.](https://computese.com/images/blog/ai-limitations-in-understanding/no-op.67bef0127d-1536.webp)

*A detail that changes nothing should change nothing. The models treated it as a step to compute.*

The authors conclude that the models convert statements into operations by pattern rather than by understanding what they mean. Other failures point the same way. The [reversal curse](https://arxiv.org/abs/2309.12288) study (2023) found that models which learn "A is B" do not automatically learn "B is A": GPT-4 named a celebrity's mother correctly 79% of the time, but named the celebrity from the mother's name only 33% of the time.

Asking the model to check its own work is not a dependable fix. A study presented at ICLR 2024, [Large Language Models Cannot Self-Correct Reasoning Yet](https://arxiv.org/abs/2310.01798), found that models struggled to correct their reasoning without outside feedback and sometimes got worse after trying. Newer models built for reasoning narrow the gap without closing it: o1-preview was the strongest model on GSM-NoOp and still lost 17.5 points. How those reasoning models work, and where they still fail, is covered in our guide to [logical AI](https://computese.com/exploring-the-new-frontier-in-ai-logical/).

## No grounding, and no memory of its own

A model's view of your situation is limited to two things: what it absorbed in training and what the application sends with each request.

- **Knowledge cutoff.** Training data ends on a date, and vendors publish it. As of September 2026, Anthropic's [models overview](https://platform.claude.com/docs/en/models/overview) lists both a training data cutoff and a reliable knowledge cutoff for each model, and for some models the two dates are months apart. Ask about anything later and the model either says it does not know or fills the gap with something plausible.
- **No memory between requests.** Anthropic's [Messages API documentation](https://platform.claude.com/docs/en/build-with-claude/working-with-messages) states that the API is stateless, so the application sends the full conversation history every time. OpenAI's [conversation state guide](https://developers.openai.com/api/docs/guides/conversation-state) describes each request as independent and stateless, and even when OpenAI keeps the thread for you, every earlier turn is billed again as input. What looks like memory is earlier text sent back in with each request.
- **An unevenly read context window.** Everything the model knows about the task has to fit in the context window, and even then it is not used evenly. [Lost in the Middle](https://arxiv.org/abs/2307.03172) (Liu et al., TACL) found that performance was often highest when the relevant information sat at the beginning or end of the input, and dropped significantly when it sat in the middle of a long context.
- **No contact with the world.** A text model has never seen the warehouse, the patient or the invoice, only how people write about them. That is enough for drafting and summarizing, and not enough to notice when the source text is itself wrong.

The standard remedy is retrieval-augmented generation (RAG): search approved sources when the question arrives and give the relevant passages to the model along with it. The 2020 paper that introduced RAG models, [Lewis et al.](https://arxiv.org/abs/2005.11401), found that RAG models produced more specific and factual text than a model answering from its trained parameters alone. RAG narrows the grounding problem; as the next sections show, it does not remove it.

## Why the same question gets different answers

Language models are sensitive to details a person would ignore:

- **Formatting.** [Sclar et al.](https://arxiv.org/abs/2310.11324) (ICLR 2024) changed only the format of few-shot prompts, such as separators, spacing and the capitalization of field names, and measured differences of up to 76 accuracy points with LLaMA-2-13B. How well a format worked for one model said little about how it would work for another.
- **The user's opinion.** [Sharma et al.](https://arxiv.org/abs/2310.13548) (2023) found that five AI assistants consistently showed sycophancy, bending answers toward the views users expressed. Human raters and preference models sometimes preferred a convincing sycophantic answer over a correct one, which is how training on their ratings can reward it. A question that signals the answer you expect pulls the model toward it.
- **Chance.** The same prompt can produce different answers on different runs, as the three birthdays above showed. One good answer is one sample, not a guarantee.
- **Instructions hidden in data (prompt injection).** A model cannot reliably tell the instructions it should follow from the content it is reading. [OWASP's LLM01:2025 Prompt Injection](https://genai.owasp.org/llmrisk/llm01-prompt-injection/) describes how text in a web page or file the model processes can change its behaviour, and notes that RAG and fine-tuning do not fully prevent it.

## Why critical applications need caution

A wrong sentence in a marketing draft costs an edit. A wrong answer in a diagnosis, a legal filing, a credit decision or a customer's refund costs far more, and these are the settings where the limits above are hardest to spot. The evidence is specific:

- **Confabulation in consequential decisions.** NIST AI 600-1 gives the example of a confabulated summary of patient information leading doctors to an incorrect diagnosis or treatment, and says the risk deserves particular monitoring wherever generative AI feeds consequential decisions.
- **Automation bias.** The same profile warns that as AI systems become more reliable, people may over-rely on them and defer to their output, which makes every confabulation more dangerous. The more often a system is right, the easier it is for its reviewers to stop checking.
- **Retrieval is not a guarantee.** In a preregistered 2024 study, [Stanford and Yale researchers](https://arxiv.org/abs/2405.20362) found that leading AI legal research tools, built with retrieval and marketed as reducing or eliminating hallucinations, still hallucinated between 17% and 33% of the time, although less than GPT-4 alone.
- **The organization owns the answer.** In [Moffatt v. Air Canada](https://decisions.civilresolutionbc.ca/crt/crtd/en/item/525448/index.do) (February 14, 2024), the support chatbot on the airline's website told a customer that a bereavement fare could be claimed within 90 days of the ticket being issued, even after travelling. The airline's own bereavement page, which the chatbot linked to, said the policy did not apply once travel was complete. The airline argued it was not liable for its chatbot. British Columbia's Civil Resolution Tribunal disagreed, found that a company is responsible for all the information on its website whether it comes from a static page or a chatbot, and ordered it to pay $812.02 in damages, interest and fees. (The decision does not say what technology the chatbot used; the principle applies to any automated answer.)

Regulators have written the same lesson into law. Article 14 of the [EU AI Act](https://eur-lex.europa.eu/eli/reg/2024/1689/oj) requires high-risk AI systems to be designed so that the people overseeing them can understand the system's capacities and limitations, stay aware of automation bias, interpret its output correctly, decide not to use it or override it, and stop it safely.

> [!IMPORTANT]
> Responsibility does not move to the model. If an AI system's answer reaches a customer, a patient or a ledger, your organization made that statement, and it needs the same checks as anything else you publish or decide.

## How to use AI safely where mistakes matter

None of this means avoiding AI. It means designing so that the model's weak points never decide the outcome alone. Each limit has a matching control:

| Limit                    | Where it shows up                                  | What catches it                                        |
| ------------------------ | -------------------------------------------------- | ------------------------------------------------------ |
| Hallucination            | Invented facts, citations, policies                | Answers from approved sources, with citations checked  |
| Missing world model      | Failure when conditions change                     | Test cases that change the conditions on purpose       |
| Brittle reasoning        | New numbers or irrelevant details derail the steps | Varied real cases in the evaluation set; rule checks   |
| No grounding or memory   | Stale or missing facts about your business         | Retrieval from maintained sources; explicit context    |
| Prompt sensitivity       | Answers change with wording, format or opinion     | Fixed prompts, regression tests, injection tests       |
| Fluent, confident output | Reviewers stop checking (automation bias)          | A person who approves, can override and knows the gaps |

In practice, that becomes a sequence:

1. **Decide what the model may do.** List each task (draft, classify, extract, answer) and each action it could trigger, and mark which ones need a person's approval. Anything that changes data or reaches a customer is a candidate.
2. **Ground it in approved sources.** Use retrieval over content someone maintains, show the sources behind each answer, and make "I don't know" an acceptable result when nothing relevant is found. OWASP's [LLM09:2025 Misinformation](https://genai.owasp.org/llmrisk/llm092025-misinformation/) recommends the same pairing of retrieval, cross-checking and human oversight.
3. **Evaluate on real cases, including changed ones.** The [NIST AI RMF](https://www.nist.gov/publications/artificial-intelligence-risk-management-framework-ai-rmf-10) asks for test sets representative of the conditions of expected use and for documenting where a system's performance does not generalize. Build the set from your own questions, then add the variations the research warns about: reworded questions, new numbers, irrelevant details and unusual situations. Run it again before every model, prompt or source change.
4. **Verify with something other than the model.** Schema checks, business rules, calculations in code and links back to the source catch errors that self-review misses.
5. **Keep a person in the loop and accountable, and design against automation bias.** Reviewers should know the system's limits, see its sources, and be able to override or stop it. OWASP also recommends training reviewers so they do not over-rely on the output.
6. **Monitor in production.** Log inputs, sources, answers and approvals, review samples regularly, and watch for drift when the model, the data or the questions change.

A grounded design puts those steps in one path: the question goes to retrieval over approved content, the model drafts an answer that cites what it used, and nothing changes in a system of record until a rule or a person approves it.

![A question card reaches a chip that pulls two documents from a locked cabinet. The answer card links back to them and passes an orange approval shield before reaching a server.](https://computese.com/images/blog/ai-limitations-in-understanding/grounded.222c917802-1536.webp)

*Answer from approved sources, show where each claim came from, and stop at an approval gate before anything changes.*

To organize the work, use the [NIST AI Risk Management Framework](https://www.nist.gov/itl/ai-risk-management-framework). AI RMF 1.0, released on January 26, 2023, groups risk management into four functions: Govern, Map, Measure and Manage. NIST AI 600-1, released on July 26, 2024, applies it to generative AI. As of September 2026, NIST says AI RMF 1.0 is being revised under the White House AI Action Plan, and on April 7, 2026 it released a concept note for a profile on AI in critical infrastructure, so check the page for the current version before you map your controls to it.

If you are planning an assistant or automation where errors carry real cost, our [AI automation service](https://computese.com/services/ai-automation/) builds assistants that answer from your own content, cite their sources and say when they do not know. Every model, prompt or source change must first pass an evaluation set built from your real cases, anything that changes data is approved by a rule you signed off or a named person, and findings are mapped to the NIST AI RMF.

## Key terms
- **Large language model (LLM)**: A neural network, usually a transformer, trained on large amounts of text to predict the next token. Chat assistants such as ChatGPT, Claude and Gemini are built on LLMs.
- **Hallucination (confabulation)**: Output that is fluent and plausible but false or unsupported, such as an invented citation or policy. NIST calls it confabulation: confidently stated but erroneous or false content.
- **World model**: An internal representation of how a domain works, its states and rules, that lets a system handle situations it has not seen before.
- **Symbol grounding**: The link between symbols, such as words, and the things they refer to. A text-only model knows words mainly through other words.
- **Knowledge cutoff**: The date the model's training data ends. The model knows nothing after it unless the application supplies that information in the prompt.
- **Context window**: The amount of text a model can read in one request: the instructions, the conversation so far and any documents supplied. It is the model's only working memory.
- **Retrieval-augmented generation (RAG)**: A design where the application searches approved sources at question time and passes the relevant passages to the model, so answers can be drawn from and checked against them.
- **Automation bias**: The tendency to over-rely on a system's output and defer to it even when it is wrong. NIST and the EU AI Act both name it as a risk to manage.
- **Sycophancy**: A model's tendency to tell users what they appear to believe rather than what is accurate, linked in research to training on human preference ratings.
- **Prompt injection**: Input, including hidden text in a web page or file the model reads, that changes the model's behaviour in ways its developers did not intend.

## Common questions

### Does AI really understand what it says?

Not in the way its answers suggest. A language model predicts likely text from patterns in its training data, and research such as the 2024 world-model study reported by MIT shows a model can be highly accurate without having learned the structure behind a task. Some models do form useful internal representations, but you cannot infer understanding from fluency or a benchmark score.

### Why does AI make things up?

Because it is built to produce plausible text, and plausible is not the same as true. A 2025 paper by OpenAI and Georgia Tech researchers traces hallucinations to facts too rare in training data to learn and to evaluations that reward guessing over saying 'I don't know'. The result is a confident answer even when the model has no reliable basis for one.

### Can AI tell when it does not know something?

Only partly. Methods such as semantic entropy, published in Nature in 2024, detect some confabulations by sampling several answers and checking whether their meanings agree. But models asked to check their own reasoning without outside feedback often fail to fix it and sometimes make it worse, so verification should come from sources, rules or people outside the model.

### Does retrieval-augmented generation stop hallucinations?

It reduces them, it does not stop them. In a 2024 preregistered study by Stanford and Yale researchers, legal research tools built with retrieval still hallucinated between 17% and 33% of the time, though less than GPT-4 on its own. Retrieval works best with maintained sources, visible citations and an evaluation that checks answers against those sources.

### Will bigger models fix these limitations?

The strongest models in these studies made fewer errors, but none was free of them. In the GSM-Symbolic tests, o1-preview, the best performer, still lost 17.5 points when one irrelevant sentence was added to math problems, and a 2024 theoretical paper argues hallucination cannot be fully eliminated in models used as general problem solvers. Plan for errors rather than waiting for them to disappear.

### Should AI be used for critical decisions?

It can support them, with a person accountable for the decision. Use it where its output can be checked against approved sources, test it on real cases before and after every change, and make sure reviewers can see its limits, override it and stop it. The EU AI Act requires this kind of human oversight for high-risk systems, and the NIST AI RMF gives a structure for managing the rest.

## Sources
1. [Despite its impressive output, generative AI doesn't have a coherent understanding of the world](https://news.mit.edu/2024/generative-ai-lacks-coherent-world-understanding-1105), MIT News
2. [Evaluating the World Model Implicit in a Generative Model (Vafa et al., NeurIPS 2024)](https://arxiv.org/abs/2406.03689), arXiv
3. [NIST AI 600-1: Artificial Intelligence Risk Management Framework: Generative Artificial Intelligence Profile](https://www.nist.gov/publications/artificial-intelligence-risk-management-framework-generative-artificial-intelligence), NIST
4. [The Symbol Grounding Problem (Harnad, Physica D, 1990)](https://arxiv.org/abs/cs/9906002), arXiv
5. [Why Language Models Hallucinate (Kalai et al., 2025)](https://arxiv.org/abs/2509.04664), arXiv
6. [Hallucination is Inevitable: An Innate Limitation of Large Language Models (Xu et al., 2024)](https://arxiv.org/abs/2401.11817), arXiv
7. [Detecting hallucinations in large language models using semantic entropy (Farquhar et al., 2024)](https://www.nature.com/articles/s41586-024-07421-0), Nature
8. [GSM-Symbolic: Understanding the Limitations of Mathematical Reasoning in Large Language Models](https://machinelearning.apple.com/research/gsm-symbolic), Apple Machine Learning Research
9. [GSM-Symbolic, full paper (Mirzadeh et al., 2024)](https://arxiv.org/abs/2410.05229), arXiv
10. [The Reversal Curse: LLMs trained on 'A is B' fail to learn 'B is A' (Berglund et al., 2023)](https://arxiv.org/abs/2309.12288), arXiv
11. [Large Language Models Cannot Self-Correct Reasoning Yet (Huang et al., ICLR 2024)](https://arxiv.org/abs/2310.01798), arXiv
12. [Models overview](https://platform.claude.com/docs/en/models/overview), Anthropic
13. [Using the Messages API](https://platform.claude.com/docs/en/build-with-claude/working-with-messages), Anthropic
14. [Conversation state](https://developers.openai.com/api/docs/guides/conversation-state), OpenAI
15. [Lost in the Middle: How Language Models Use Long Contexts (Liu et al., TACL)](https://arxiv.org/abs/2307.03172), arXiv
16. [Retrieval-Augmented Generation for Knowledge-Intensive NLP Tasks (Lewis et al., NeurIPS 2020)](https://arxiv.org/abs/2005.11401), arXiv
17. [Quantifying Language Models' Sensitivity to Spurious Features in Prompt Design (Sclar et al., ICLR 2024)](https://arxiv.org/abs/2310.11324), arXiv
18. [Towards Understanding Sycophancy in Language Models (Sharma et al., 2023)](https://arxiv.org/abs/2310.13548), arXiv
19. [LLM01:2025 Prompt Injection](https://genai.owasp.org/llmrisk/llm01-prompt-injection/), OWASP Gen AI Security Project
20. [Hallucination-Free? Assessing the Reliability of Leading AI Legal Research Tools (Magesh et al., 2024)](https://arxiv.org/abs/2405.20362), arXiv
21. [Moffatt v. Air Canada, 2024 BCCRT 149](https://decisions.civilresolutionbc.ca/crt/crtd/en/item/525448/index.do), Civil Resolution Tribunal of British Columbia
22. [Regulation (EU) 2024/1689 (Artificial Intelligence Act), Article 14: Human oversight](https://eur-lex.europa.eu/eli/reg/2024/1689/oj), EUR-Lex
23. [LLM09:2025 Misinformation](https://genai.owasp.org/llmrisk/llm092025-misinformation/), OWASP Gen AI Security Project
24. [NIST AI 100-1: Artificial Intelligence Risk Management Framework (AI RMF 1.0)](https://www.nist.gov/publications/artificial-intelligence-risk-management-framework-ai-rmf-10), NIST
25. [AI Risk Management Framework](https://www.nist.gov/itl/ai-risk-management-framework), NIST