💬 NLP

ATOM: AdapTive and OptiMized dynamic temporal knowledge graph construction using LLMs

This paper introduces ATOM, a few-shot and scalable framework that constructs and continuously updates Temporal Knowledge Graphs from unstructured text by decomposing inputs into stable "atomic" facts and employing dual-time modeling, thereby significantly improving exhaustivity, stability, and latency compared to existing methods.

Original authors: Yassir Lairgi, Ludovic Moncla, Khalid Benabdeslem, Rémy Cazabet, Pierre Cléau

Published 2026-01-27

📖 5 min read🧠 Deep dive

CC BY 4.0

Original authors: Yassir Lairgi, Ludovic Moncla, Khalid Benabdeslem, Rémy Cazabet, Pierre Cléau

Original paper licensed under CC BY 4.0 (http://creativecommons.org/licenses/by/4.0/). ✨ This is an AI-generated explanation of the paper below. It is not written or endorsed by the authors. For technical accuracy, refer to the original paper. Read full disclaimer

Imagine you are trying to build a massive, living library of facts about the world, but the books you are reading are messy, unorganized news articles that change every day. This is the challenge of creating a Temporal Knowledge Graph (TKG)—a map of facts that knows not just what happened, but when it happened and how long it lasted.

The paper introduces a new system called ATOM (AdapTive and OptiMized) to solve the problems of building this library using Artificial Intelligence (specifically Large Language Models, or LLMs).

Here is how ATOM works, explained through simple analogies:

The Problem: The "Overwhelmed Librarian"

Traditional methods try to feed a whole news article to an AI and ask, "What are the facts and dates here?"

The Issue: If the article is long, the AI gets overwhelmed. It's like a librarian trying to read a 500-page book in one sitting; they remember the exciting beginning and the dramatic end, but they forget the important details in the middle. This leads to missing facts (low "exhaustivity").
The Instability: If you ask the same AI to read the same article twice, it might give you two slightly different lists of facts. It's like a librarian who is a bit forgetful and inconsistent.
The Speed: Doing this one article at a time, step-by-step, is incredibly slow.

The Solution: ATOM's "Atomic" Strategy

ATOM changes the game by breaking the problem down into tiny, manageable pieces. Think of it as a high-speed factory assembly line rather than a single person reading a book.

1. The "Atomic Fact" Decomposition (The Puzzle Pieces)

Instead of giving the AI a whole paragraph, ATOM first chops the text into tiny, self-contained "atomic facts."

Analogy: Imagine a complex sentence like a jigsaw puzzle. Instead of asking the AI to solve the whole puzzle at once, ATOM cuts the picture into individual puzzle pieces first. Each piece contains only one clear fact.
Why it helps: This prevents the AI from getting confused or forgetting details. It forces the AI to focus on one tiny truth at a time, ensuring nothing is missed.

2. The "Dual-Time" Clock (The Two Clocks)

ATOM is smart about time. It distinguishes between two different clocks:

The Observation Clock: When did we see this news? (e.g., "This article was published yesterday.")
The Validity Clock: When was this fact actually true? (e.g., "The CEO served from 2010 to 2020.")
Analogy: Imagine a detective writing a report. One clock says "I found this clue on Tuesday," and another clock says "This clue proves the suspect was in town on Monday." ATOM keeps these two times separate so the history is accurate.

3. The Parallel Assembly Line (The Factory)

This is where ATOM gets fast.

The Old Way: Process Fact 1, then Fact 2, then Fact 3... one by one.
ATOM's Way: It takes hundreds of "atomic facts" and sends them to the AI all at once (in parallel).
Analogy: Imagine a factory with 8 workers (threads) instead of 1. While one worker is checking a fact about a CEO, another is checking a fact about a weather event. They all work simultaneously.
The Merge: Once the AI extracts the facts, ATOM uses a fast, mathematical "glue" to stick the pieces together. Crucially, it does not ask the AI to do the gluing; it uses a computer algorithm. This avoids asking the AI to read its own massive memory, which keeps the system fast and prevents it from getting confused as the graph grows.

The Results: What Did They Find?

The authors tested ATOM against other methods (like Graphiti and iText2KG) using real news data about the COVID-19 pandemic.

More Complete: ATOM found about 18% more facts than the other methods. It didn't miss the details in the middle of the text.
More Consistent: If you ran the system three times, it gave almost the same result every time (33% more stable). It stopped being "forgetful."
Much Faster: Because it works in parallel and doesn't over-rely on the AI for the final merging steps, it was over 90% faster (reduced latency) than the competitors.

The Catch (Limitations)

The paper admits ATOM isn't perfect:

The "Inference" Risk: Because it breaks text into tiny pieces, the AI sometimes tries to be too helpful and "infers" a fact that wasn't explicitly written, leading to a few made-up details (hallucinations).
Cost: Breaking text down and processing it in parallel requires more computer power (and money) than just reading a text once.

Summary

ATOM is a new way to build a living map of the world's facts. Instead of asking an AI to read a whole book and hope it remembers everything, ATOM cuts the book into tiny sentences, asks the AI to process them all at once, and then uses a fast computer algorithm to stitch them together. The result is a map that is faster, more complete, and more reliable than previous attempts.

Technical Summary: ATOM – AdapTive and OptiMized Dynamic Temporal Knowledge Graph Construction

1. Problem Statement

The construction of Knowledge Graphs (KGs) from unstructured text is critical for real-time analytics and dynamic memory frameworks. However, traditional static KGs fail to capture the time-sensitive nature of real-world data. While Temporal Knowledge Graphs (TKGs) address this by associating timestamps with facts, existing approaches face three primary limitations when deployed in production:

Lack of Exhaustivity: Current zero-shot or few-shot methods often omit key relationships, particularly as input context length increases, due to the "forgetting effect" in Large Language Models (LLMs).
Instability: Multiple runs of the same extraction prompt on identical text often yield different results, leading to inconsistent graph structures.
Scalability and Latency: Sequential processing and heavy reliance on LLM calls for entity resolution and temporal merging create bottlenecks, making real-time updates impractical for large-scale datasets.

Furthermore, many existing methods conflate the time an observation is made with the validity period of the fact itself, leading to temporal inaccuracies.

2. Methodology: The ATOM Framework

The authors propose ATOM (AdapTive and OptiMized), a few-shot, scalable framework designed to construct and continuously update Dynamic Temporal Knowledge Graphs (DTKGs). The architecture is defined by a dual-time modeling approach and a parallel processing pipeline.

2.1 Dual-Time Modeling

ATOM distinguishes between two temporal dimensions:

Observation Time ( $t_{obs}$ ): When the information was observed or ingested.
Validity Period ( $t_{start}, t_{end}$ ): The inherent time interval during which the fact holds true.
This separation allows the system to handle relative temporal expressions (e.g., "a month ago") by using the observation time as context for the LLM to infer the validity period.

2.2 Core Architecture

The framework operates through three sequential modules:

Module 1: Atomic Fact Decomposition
Instead of processing raw documents directly, ATOM decomposes unstructured text into minimal, self-contained "atomic facts." Each fact conveys exactly one piece of information.

Rationale: This mitigates the LLM "forgetting effect" where models prioritize salient information in long contexts and omit key relationships.
Optimization: Experiments determined an optimal chunk size of < 400 tokens to maintain high exhaustivity (> 0.8).

Module 2: Atomic TKG Construction
From each atomic fact, the system extracts 5-tuples (subject, relation, object, $t_{start}$ , $t_{end}$ ) in parallel.

Preprocessing: During extraction, the system transforms "end-action" facts (e.g., "is no longer CEO") into affirmative counterparts with modified end-times (e.g., setting $t_{end}$ ) to facilitate later merging.
Context: Few-shot examples are provided to guide the LLM in handling relative time expressions.

Module 3: Parallel Atomic Merge and DTKG Update
The extracted atomic TKGs are merged in parallel using a binary merge algorithm, avoiding LLM calls during the merging phase to ensure scalability.

Entity Resolution: Merges entities based on exact matches or cosine similarity ( $\theta_E = 0.8$ ).
Relation Resolution: Merges relation names based on semantic similarity ( $\theta_R = 0.7$ ).
Temporal Resolution: Detects and aligns facts with the same $(subject, relation, object)$ but different validity periods, extending the history of the fact rather than creating duplicate edges.
Parallelism: The merge process is iterative and parallelized, reducing the number of TKGs step-by-step until a single consolidated snapshot is obtained.

3. Key Contributions

Atomic Decomposition Strategy: A novel approach to breaking down text into atomic facts to enhance both exhaustivity and stability in LLM-based extraction.
Dual-Time Modeling: A formal definition of DTKGs that separates observation time from validity periods, improving temporal reasoning accuracy.
Scalable Parallel Architecture: A pipeline that decouples extraction and merging, utilizing parallel processing to reduce latency significantly compared to sequential or LLM-dependent merging methods.
Open-Source Implementation: The framework is released as an open-source Python library with associated code, prompts, and datasets.

4. Experimental Results

The authors evaluated ATOM on the 2020-COVID-NYT subset (1,076 articles) against baselines including Graphiti and iText2KG.

Exhaustivity: ATOM achieved approximately 18% higher exhaustivity in factual-temporal recall ( $R_{f,t}$ ) compared to baseline methods. It demonstrated that decomposing text into atomic facts prevents information loss common in long-context processing.
Stability: By using atomic facts, ATOM improved stability (measured by Jaccard similarity across runs) by approximately 33%, significantly reducing the variance in output compared to processing raw lead paragraphs.
Latency and Scalability: The parallel architecture resulted in a >90% reduction in latency (93.8% vs. Graphiti; 95.3% vs. iText2KG). The system scales effectively with the number of input facts, whereas baselines suffer from increasing latency due to sequential or LLM-heavy resolution steps.
Consistency: ATOM demonstrated superior performance in temporal resolution, correctly merging facts with different validity periods into a single history, whereas Graphiti tended to create separate relations.

Note on Trade-offs: The increased exhaustivity came with a marginal decrease in factual precision (~~9%) and factual-temporal precision (~~1%), attributed to the generation of semantically plausible but not strictly gold-standard "inferred" facts during decomposition and minor errors in temporal assignment.

5. Significance and Claims

The paper claims that ATOM addresses the critical gap between the theoretical potential of TKGs and their practical deployment in dynamic, real-time environments. By ensuring stability and exhaustivity through atomic decomposition and achieving scalability through parallel merging, ATOM enables the continuous, low-latency updating of knowledge graphs.

The authors position ATOM as a robust solution for agentic systems requiring dynamic memory and for applications needing real-time temporal inference. They acknowledge limitations, including potential error propagation from the decomposition step and the computational cost of the two-step process, suggesting that future work could involve fine-tuning LLMs specifically for atomic fact decomposition to further optimize performance and cost.