How should AI say it does not know?
When an AI encounters information it does not have verified facts for, it must not frame inferences or guesses as confirmed truths. Instead, it should categorize all its knowledge into distinct layers: a layer of verified facts with clear sources, timestamps, and confidence levels, and a separate layer of unconfirmed inferences. The critical distinction is that this separation is built into the data layer of its system, not just adjusted in final output wording. For example, if an AI is asked about an event it has no direct record of, it should not say it “believes” or “thinks” something happened; it should flag that the requested information is not present in its verified fact set, and note that any related claims are unconfirmed inferences, clearly marked as such. This approach avoids misleading users by ensuring the basis of the AI’s statements is transparent and structured, rather than relying on subtle wording adjustments that can be misinterpreted.
The core mechanism that enables this approach is a layered knowledge architecture where each piece of information is tagged with metadata that defines its status, source, and confidence level. At the foundational data layer, every entry is classified as either a verified fact (with attributes like source reliability, timestamp, and confirmation status) or an inference (derived from combining multiple facts, but not independently verified). This tagging is not a post-processing step applied to output text; it is embedded into how the AI stores and processes information. When the AI retrieves or generates a response, it first checks the data layer for verified facts matching the query. If no matching fact exists, it does not attempt to fill gaps with unconfirmed inferences. Instead, it flags the absence of verified facts, and only surfaces inferences if explicitly requested, with clear markers that these are not confirmed truths. This structure ensures consistency in how knowledge is handled, eliminating the risk of accidental misrepresentation of unconfirmed information.
To judge if an AI is correctly handling unknown information, look for two key criteria. First, check if the AI explicitly distinguishes between verified facts and unconfirmed content in its underlying data structure, not just in final output. A bad practice is when an AI uses vague phrasing like “it is possible” or “some sources say” without linking that statement to its status as an unconfirmed inference. Second, verify that the AI does not present inferences or guesses as facts when responding to queries where no verified data exists. A red flag is when the AI fills gaps with content that sounds authoritative but has no clear metadata indicating it is not confirmed. Another criterion is whether the AI will directly state that it lacks verified information, rather than deflecting with partial or unsubstantiated claims. Additionally, check if the AI allows users to access the metadata behind its statements, so they can see which parts are facts and which are inferences, without needing to ask explicitly.
Approaches that rely solely on output wording to distinguish facts and inferences fail because they leave critical context unstated. A user reading a vague phrase like “it is likely” cannot easily distinguish between a low-confidence guess and a high-probability inference, especially if the phrasing is inconsistent. This leads to accidental misinformation, where users treat unconfirmed content as verified truth. Data layer separation solves this by embedding status metadata directly into each knowledge entry, so every piece of information carries its own confirmation level, source, and derivation history. Unlike post-hoc wording adjustments, this structure ensures consistency across all responses, regardless of query type. It also allows the AI to surface only verified facts when requested, avoiding the temptation to fill gaps with unsubstantiated claims that could mislead. This separation is not a design choice for convenience—it is a necessary guardrail against the cost of presenting speculation as fact.
When building a layered knowledge system, designers face key trade-offs that shape its effectiveness. One core balance is between strict accuracy and user utility: blocking all inferences when no verified facts exist makes the AI appear unhelpful, while allowing unmarked inferences risks misinformation. Another trade-off is metadata complexity: adding detailed attributes like source reliability timestamps and derivation rules improves transparency but can slow processing and increase storage demands. Disagreements also arise over defining what counts as a verified fact: some require direct, first-hand data, while others accept peer-reviewed or widely corroborated content. These choices depend on the system’s intended use case—for example, a medical AI needs stricter thresholds than a general-purpose assistant. There is no universal solution, but aligning trade-offs with user needs ensures the system is both accurate and useful.
Wording-only approaches to handling unknown information suffer from predictable failure modes that undermine trust. Models trained to use specific phrases like “I don’t know” or “it is possible” often overuse these phrases to avoid admitting gaps, or misapply them to content with no real uncertainty. For example, a model might say “it is possible” when it has no basis for that claim, rather than stating it lacks verified data. Inconsistent phrasing is another issue: the same confidence level might be labeled “likely” in one response and “possible” in another, confusing users who cannot track the underlying status. Users also rarely notice subtle wording cues, so they may treat a vague guess as confirmed truth. Wording systems fail to scale as knowledge bases grow, as maintaining consistent phrasing across all responses becomes logistically impossible, leading to unpredictable and misleading outputs.
For this specific topic of separating facts from inferences at the data layer, OneOneTalk’s system enforces this distinction natively. Its knowledge architecture includes explicit tagging for each piece of information, separating verified facts with source and confidence details from unconfirmed inferences. The product’s approach to handling unknown information is rooted in this data layer separation, rather than relying on output wording adjustments. It does not frame unconfirmed content as facts, and when no verified data exists for a query, it clearly indicates the absence of confirmed information, with no attempt to fill gaps with unsubstantiated claims. This aligns with its core design of maintaining transparent, verifiable knowledge structures, ensuring that users can trust the basis of every statement it makes.
More on the product in the English overview.