짐 캐리 사망 오보로 본 지식 시스템의 한계

Previous Post The Reports of Jim Carrey's Death are a Failure Mode Published: Jul 1, 2026 | ~ 4200 words | ~ 20 minutes reading time Knowledge Graphs Google Exploits Security Enterprise On the 29th June 2026 - if you searched for Jim Carrey on Google, you would have been presented with a Knowledge Panel stating that he had died the previous day. The panel included a date of death and a biography written in the past tense. For most people who would have seen this, it may have come as a shock - some may have even believed it - but for me, what I saw was a canary in the coal mine. It was a visible failure mode of a knowledge system that I have been thinking about for a while now. A trusted source? Clicking on the date of death brings up Google’s own AI - Gemini - which stated that reports of his death were false. This led me to do a bit of my own digging around, and I could only find one source - an edit on the Wikipedia page that cited the Maui Police Department’s Facebook page and an established BBC article about former US President Jimmy Carter’s death. It would seem this is an open-and-shut case: Wikipedia was edited, Google consumed the edit, their Knowledge Graph updated and presented this as a fact - but now we have two conflicting reports from the same company - one saying he is dead, and the other saying he is alive. I don’t know exactly where the false claim entered Google’s systems and whether the Wikipedia edit was involved. All we can infer is that a combination of source weighting, entity resolution, indexing, freshness signals and internal systems produced the result. From outside the company, there is no way to know that. Google’s own description of the Knowledge Graph has always made clear that it is assembled from multiple public and web-derived sources, structured information and internal interpretation. The panel is the user interface to the knowledge of a much larger, opaque pipeline. Somewhere in that pipeline, a claim crossed a threshold and stopped being information that existed somewhere on the web and became knowledge presented by an interface that many people use and trust to find information. Building knowledge systems is hard My day job involves building knowledge systems. That description tends to make people think of the technologies involved: content, knowledge and document management systems, APIs, knowledge graphs, product information, search, integrations, semantic models, and now AI. While those things do matter, the main bulk of my work is less about moving information between systems and more about building systems that people can trust. Every system that receives information has to make a judgement about it - in biological systems we call this perception, in technological systems we call this inference. “Does this agree with what I already know?” “Is the source authoritative in this domain?” “Has this changed since the last time I saw it?” “Does it conflict with something else?” “Is the claim sufficiently important, recent or well-supported to pass further downstream?” By the time a user sees an answer, those decisions have already been made several times by systems they will never see, and algorithms they will never be shown. In the end, all the user sees is a result, but not the process that produced it. We use the words information and knowledge almost interchangeably, although they describe very different things. Information is a claim about the world. Knowledge is a claim that has survived enough scrutiny that another person, or increasingly another system, is prepared to act on it. The transition between those states is almost entirely invisible: users only see an output or outcome - those decisions have already been made several times by systems they will never see, and algorithms they will never be shown. They do not see the claims that were discarded, the sources which disagreed, the confidence thresholds, the causal relationships between documents, or the fact that another internal system may have reached a different conclusion. One of the great sins of UX Design is that the interface tends to present the final answer as though it arrived fully formed. The report of Jim Carrey’s death itself is of low consequence, but it exposed that hidden process for a brief moment - a claim that should have remained an assertion appears to have been promoted before the available evidence confirmed it. Whether that was caused by malicious manipulation, a weakness in source reconciliation, a problem in how to handle fresh data, or some combination of those things is almost secondary. The failure mode exists either way. A knowledge system can inherit confidence from upstream sources faster than it inherits the verification required to deserve that confidence. The shape of misinformation Propaganda and misinformation existed long before the internet era, but with opaque systems it’s never been easier and faster to produce them. A false article is published, designed to trigger people’s emotions, people share it, and by the time journalists or fact-checkers catch up, the narrative has already achieved much of its purpose. The old line, usually attributed to Mark Twain even though the attribution itself is uncertain, says that a lie travels halfway around the world while the truth is still putting on its shoes. In the past, you needed to own a media empire to achieve this. Today, all it needs is a social media platform and people to click, share and like. The speed of distribution has increased, but the underlying pattern is the same: a claim can be repeated and amplified faster than it can be verified. But I believe that now in the ‘Age of AI’ there is a new emergent version that looks less social-technical and more like an infrastructure problem. A false claim does not need to persuade millions of people individually if it can persuade, or merely pass through, the systems that decide what millions of people see. A carefully shaped claim with plausible references, structured fields, apparent corroboration and the right entity identifiers can become input to the systems that now summarise, rank, recommend and answer on our behalf. The target has moved upstream from users to the machines that mediate people’s relationship with reality. Software engineering is already grappling with this as supply-chain risk. For a long time, software security was focused on applications - RBAC, access control lists, security patches - but then it became obvious that applications were not the only attractive target, and attacking dependencies is much cheaper and easier to do. Modern software supply-chain practice is built around provenance, attestations, reproducible builds, signatures and the ability to trace an artefact back through the process or pipeline that created it. We have learned that software cannot be trusted simply because it is available in a repository run by large organisations: trust depends on understanding where it came from, who created it, how it was assembled and what metadata has been attached to it along the way. I believe the same is now true of knowledge. Claims also have origins, dependencies and supply chains - they inherit trust from upstream systems, but they also inherit mistakes, gaps and manipulation. A claim copied across a hundred pages may look like consensus while remaining one upstream observation reflected in a hundred different places. A citation can look like evidence while pointing towards a source that does not support the claim. A polished summary can make uncertainty disappear without resolving it. We’ve fallen into a trap where information has not become more reliable; it merely acquires the appearance of reliability. That distinction is where provenance becomes more important than confidence. A system saying that it is ninety-four per cent confident is not pa