ena pragma
·17 min read·ai-verification · agent-memory · temporal-reasoning · research-method

A video said AI can now reason about time. The headline gain depends on which baseline you pick

We traced a 39-minute video on a time-aware transformer to its paper and code, checked every number, and found the part you can use today needs no training.

Contents

The short version. The part of this research you can use today is a training-free pipeline: list the events and what depends on what, check and order the dates, keep the original text beside your list, and re-check the answer against it. The paper behind the video is real and its numbers hold. But the abstract's "16.5% higher" depends on which baseline you pick: the paper never says which one it means, and the subtraction that reproduces it uses a training-free baseline on a different model. Against the authors' own fine-tuned baseline of similar size the gain is 8.3 points. The code ships without trained weights and without a training script.

On October 29, 2026, at 9:30 AM Central, the channel Discover AI posted a 39:22 video called "A New Transformer for TEMPORAL Attention" (YouTube). It walks through a paper posted four days earlier (arXiv 2610.34094). The promise: language models are weak at time, and here is a design that gives them a built-in sense of event order. A video like that is a lead, not a source. This note shows what we did with the lead, what we found when we checked it, and what you can do with the result whatever your setup.

#What we started with, and what we did with it

We did not summarize the video. We treated it as a set of claims and went looking for the owner of each one.

  1. We kept the full transcript. The first scrape of the video page returned only part of it and the subtitle download was rate limited, so we pulled the whole text through a transcript library and kept it as evidence. Auto-captions garble names. The video says "Memorella" for a paper that is really called Memorilla, and checking is what caught it.
  2. We split 39 minutes into testable claims. Who wrote the paper and when, how the model is built, the three accuracy numbers, the training data, the host's critique, and two asides. Each claim got an owner: the paper, the code, a vendor page or another study.
  3. We went to the paper and the repository. We read the paper's full text, then the repository's own files, not just its description page.
  4. We checked each quote and number against the source string. Every row on our claim sheet carries the exact words and a link. Of the 64 rows, 54 matched cleanly, 7 are true with a named gap, 3 we could not verify, and none was contradicted. We ran the checker against a planted wrong quote, and it rejected it.
  5. We read the field around it. A paper on its own tells you little about whether it matters. We looked at 2026 work on agent memory and time to see whether the problem is real and what people use today.
  6. We asked what the video could not tell us. What the headline number compares, what the repository ships, and what the authors say against themselves.

That last step produced most of what follows.

#What the paper does, in the video's own example

The video uses a small factory story. A machine repair finishes on day 2. Production restarts one day after the repair. Shipping happens two days after production restarts. The marketing department holds a meeting on day 2. The question: if the repair finishes two days later, when does shipping happen?

Doing it by hand, with the video's numbers: shipping moves from day 5 to day 7, and the marketing meeting stays where it is, because nothing depends on it. That arithmetic is ours. The paper's idea is to make a model do those steps on purpose. The video lists six: "we have extract, construct, modify, serialize, reason, and check." Pull the events out of the text, build a graph of what depends on what, edit the graph for the what if, write the graph back as text, reason over it, and check. The paper describes the same pipeline in three stages, ending in "serialized cognitive procedures and explicit invariant checking" (arXiv HTML).

There are two versions of the idea:

  • TCR-Agent is the pipeline above, run around an off-the-shelf model. No training.
  • TCR-Former builds the idea into a model: a 0.6B-parameter encoder with 128 learnable event slots, a two-layer projector and an 8B decoder, about 8.6B parameters in total. The slots use an attention mask in which text tokens see all the text and no slots, and each event slot sees all the text and only the earlier slots, so "future queries cannot inform past ones." The video notes the mask uses "token types and only slot indices," not an extracted graph.

The authors say the idea came from document layout. Their own wording is that they "observe a profound computational isomorphism between complex temporal causal reconstruction and layout structuring tasks." A model that puts scrambled page blocks into reading order is solving a cousin of putting scrambled sentences about events into time order. They credit DeepSeek-OCR 2 (January 28, 2026) for the layout side (arXiv). Moving an idea from one field to another is the interesting step in this paper, and it is easy to miss in a video about attention masks.

#What held up

Most of the video checks out against the paper. The paper's date, the 128 slots, the model sizes, the two-layer GELU projector, the three training stages (60,000 narratives labeled by DeepSeek-V3.2, then 40,000 texts, then 4,000 samples produced by running TCR-Agent on GPT-5.4 over the benchmark's training split) and the three accuracy figures all match. On Qwen-3-8B the paper reports accuracy, as scored by a language-model judge, of 60.1 for TCR-Agent, 67.4 for the same model fine-tuned on question-answer pairs generated by TCR-Agent on GPT-5.4, the kind of data TCR-Former's last stage uses, and 75.7 for TCR-Former. The host reads those as "we can increase our accuracy to 67.4" and then the final number, which is correct.

The host's best point also holds. He says the name causal sounds "stronger than the mechanism itself." The authors agree in their own Future Work: "we will attempt to establish formal connections between the Causal-Topological Attention mechanism and structural causal models." The mask orders event slots. A formal link to causal models is still to come.

#What was smaller than it looked

Here the abstract leaves the baseline unnamed, and the denominator is where it shows. The abstract says TCR-Former "achieves an accuracy 16.5% higher than that of state-of-the-art (SOTA) methods," and the conclusion says "outperforming the previous best method by 16.5%." The paper never says which baseline the 16.5 is against. In the results section the best training-free baseline is TISER on GPT-5.4, scoring 59.2, and the paper says its own agent on GPT-5.4 reached 70.4, "an 11.2% improvement over the best baseline TISER (LLM-Acc = 59.2%)." The subtraction that reproduces the 16.5 is 75.7 (TCR-Former, on Qwen-3-8B) minus 59.2 (TISER, on GPT-5.4); that is our reconstruction. TISER on the same Qwen-3-8B scores 49.2. The comparisons on the same benchmark:

Compared withTheir scoreTCR-Former's 75.7 beats it by
TISER on the same Qwen-3-8B49.226.5 points
TISER on GPT-5.4, the best training-free baseline (the only subtraction that gives 16.5)59.216.5 points
The authors' own agent pipeline on the same Qwen-3-8B60.115.6 points
The same Qwen-3-8B with LoRA fine-tuning on question-answer pairs generated by TCR-Agent on GPT-5.4, the kind of data TCR-Former's last stage uses (TCR-Former also gets two earlier training stages)67.48.3 points
The authors' own training-free agent on GPT-5.470.45.3 points

(The differences are our subtraction, except the 8.3, which is the paper's.) The 16.5 is real arithmetic, and it is points, not a percentage of the baseline. The closest comparison for a trained model is another trained model, and the paper reports that gap itself: the 67.4 baseline, "TCR-Former further improves upon this by 8.3%." That is about half the headline, with one caveat: the LoRA row did not get the two earlier training stages, and the paper does not say it did. The video did not use the 16.5 figure. We found it in the abstract.

Three more things sit around the number:

  • The repository does not ship what the video implies. The video says everything is on GitHub. We read the repo on October 29. GitHub's API lists a README, a bench folder (training and test JSON, so the full benchmark ships), a code folder with four modules plus an init file (config, decoder, encoder, pipeline), a fig folder and a requirements file. It shows no releases, 0 stars and 0 forks, and the last push was October 21. The checkpoint paths in the config are "Placeholder artifact references for open-source release," set to nothing, and no training script is among the files. A search of Hugging Face models and datasets for TCR-Former, TempoCausal and Translab-SCUT found nothing, so we say we found no weights, not that none exist.
  • The test set is smaller than it sounds, and one model did several jobs. The paper says 6,000 samples built from 1,500 TimeQA-Hard samples, split 4 to 1 (about 1,200 test items, our arithmetic). The released test file has 1,500 items from only 300 distinct stories, five questions each, so the independent units are closer to 300. The paper reports three runs averaged, and we found no spread. Scoring uses two language-model judges, DeepSeek-V3.2 and Gemini-3.1-flash. DeepSeek-V3.2 also wrote the labels for the first two training stages, and DeepSeek-V3.2 and GPT-5.4 also verified the benchmark's answers (Appendix E), and GPT-5.4 is the model whose outputs trained the final stage. That overlap is worth naming, and it is not proof of bias.
  • TCR-Former was built and tested on Qwen models only (the agent also ran on GPT-5.4 and DeepSeek-V3.2). The host was unsure which decoder the authors used; the auto-caption has him saying "I think it was a Q and or was a deep seek." The paper's decoders are Qwen. DeepSeek-V3.2 labels data, judges answers and serves as a baseline. The authors list the limit themselves: "It has currently been validated mainly on Qwen-series backbones, leaving its cross-architecture generalization yet to be further verified."

A few smaller video claims land in the same place: true in spirit, wider than the source. The video says "We have no humans in the loop." That is true of the two training-label stages as described, but the benchmark sends disagreements to people ("If the two models disagree, the case is referred to human arbitration and corrected manually."). The video also says LLMs "have no understanding of time." That is stronger than the paper's "pronounced temporal blind spots": plain GPT-5.4 scored 51.3, and the training-free agent lifted it to 70.4 with no training. The authors also say acceptance at NeurIPS 2026 on the arXiv page. We did not find it on an independent list, so we repeat it as their statement, and we found no replication from anyone else.

#What the video skipped, and what it means for builders

The most useful findings are in the paper's tables, not in the video.

The agent is the slow part, and it can be compressed. TCR-Former cut inference latency by 62% and output tokens by about 44% compared with TCR-Agent (measured with Qwen-3-8B as the base). A pipeline with six steps costs time.

The pieces do not count the same. On GPT-5.4, keeping the extracted graph but skipping the step that checks timestamps and sorts it into a valid order (the paper's DAG instantiation, per its Appendix I.1) dropped accuracy by 7.3 points (70.4 to 63.1). Removing the original text from what the model reads dropped it by 5.2 (70.4 to 65.2). That second result comes from the paper's dual-track design, where the model reads both the graph text and the raw text, so a graph that missed an exception does not erase it. Inside TCR-Former, removing the attention mask cost 8.7 points (75.7 to 67.0).

Structure is not reasoning. The authors name a "structure-reasoning disconnection." A graph that made the structure more precise still left rule-inference mistakes: "rule inference mismatch remains as high as 13.0%, nearly on par with TISER (13.8%)" for the agent (in 200 sampled Qwen-3-8B answers), against 2.8% for the trained model. Our reading: the graph tells the model what depends on what. It does not do the date arithmetic. If your agent has a shell or a calculator, hand it the arithmetic. A separate study of constrained decoding, posted October 26, finds apparent degradation "largely stems from non-equivalent prompting and output formats rather than from decoder-level masking" (arXiv 2610.35328). It is about output constraints, not our pipeline.

The authors list their own limits. The graph step "heavily relies on large language models' text-extraction capabilities," so a missed event can ripple down the graph. The benchmark is text only.

#The wider picture, October 2026

We read the field to see whether this is a real problem or a paper looking for one. It is real, and it is not about one paper.

  • STALE (May 7, 2026) tests whether an agent knows when a stored memory has been overtaken by a newer fact: 400 expert-validated scenarios, and "even the best evaluated model achieving only 55.2% overall accuracy" (arXiv 2605.06527).
  • MemStrata (June 25, 2026) finds retrieval has no model of time: "cosine similarity distinguishes a contradicted fact from a duplicated one with AUROC 0.59 (near chance)" (arXiv 2606.26511).
  • TicToc (revised April 15, 2026, and, per the authors' arXiv comment, ACL 2026 Findings) finds that no model's tool-use decisions aligned with human time perception better than 65% even with timestamps: "no model achieving a normalized alignment rate better than 65% when given time stamp information" (arXiv 2510.23853).
  • In production, Zep's vendor page describes a design where "superseded facts are invalidated, not deleted" (Zep, May 31, 2026), and Mem0's own 2026 report, updated October 10, lists "temporal reasoning, memory staleness, cross-session identity, privacy, deletion, and application-specific evaluation" as the hardest remaining problems (Mem0).

The video also mentions a memory paper he covered "a week ago." We read that as Memorilla (arXiv 2610.21375, submitted October 15, 2026, revised October 27), which reports using only 16 memory tokens (arXiv).

Our read of these together, labeled as ours: the field agrees that time is where agent memory breaks, and the answers split. One answer trains time into the model, which is what TCR-Former does. The other keeps time in the data and the prompt: dates on facts, replaced facts marked as replaced, arithmetic done by a tool. Only the second one is available to you this week.

#What we plan to do with it

This is a plan, not something we have already measured. We intend to build a small bank of about 30 time questions from our own notes (what was true on a given date, which fact a later event replaced, what slips if one step slips), score our own recall on it before changing anything, then try the pattern below and report the difference in points. We have no results yet, and we will not claim any until we have a baseline.

#Eight things to try with your own agent

None of these needs the paper's model. Each is a habit that follows from a measured piece above. We have not run these on your system, so treat each as a test, not a promise.

  1. Make the agent write a timeline table first, then check each row. Before it answers any "when" question: events, what each depends on, the delay, the date if stated. This is the paper's extract and construct steps, in a table. (The largest agent-side piece was checking and ordering the extracted graph, not just listing it: skipping that cost 7.3 points on GPT-5.4. So have the agent check each row's dates and order, not only list them.)
  2. Prune before the what if. Drop events that are not on the path to the question, like the marketing meeting. Fewer nodes leave fewer chances to slip.
  3. Do date math in code. Let the model read and structure, and let a tool add days. The paper's leftover error was rule application (13.0% of 200 sampled answers for the agent).
  4. Keep the source beside the summary. Give the agent the original text and your structured view together. Removing the raw text cost 5.2 points in the paper's test.
  5. Add a check step. Have the agent re-read the source and verify each computed date before it replies.
  6. Give memory a validity window. Store when a fact was observed and what replaced it. Invalidate, do not delete, and ask is this still true? before relying on an old note (the Zep pattern, STALE's 55.2%).
  7. Build a 30-question time test from your own data. Score it weekly, and use a different model as judge from the one that wrote the labels. The paper's judge also wrote its training labels, which is the overlap to avoid.
  8. Stamp elapsed time into the prompt. the last message was three days ago tells the agent to re-fetch instead of trusting stale context (TicToc found no model's tool-use decisions aligned with human time perception better than 65% even with timestamps, so test whether a stamp changes what your agent does).

Here is a prompt block for ideas 1 to 5. It is our adaptation of the paper's steps, not wording from the paper. Paste your report in place of the brackets.

Task: answer the date question using the report below.
1. List every event as: name | depends on | delay | date if stated.
2. Remove events that do not affect the question and say which you removed.
3. Compute dates with a tool, not in your head. Show the calculation.
4. Re-read the report and check each computed date against it. Fix any mismatch.
5. Answer. If the report and your table disagree, trust the report and say so.

Question: [your what-if question]
Report: [paste the full text]

#What we did not verify

  • We did not run the repository or recompute any benchmark number. The numbers are the authors', checked against the paper's own text.
  • NeurIPS 2026 acceptance is the authors' statement on the arXiv page and in the README. We did not find it on an independent list.
  • We found no independent replication or critique of TCR-Former. We ran two search queries, and they returned the paper and the repository. Absence from one index is not proof.
  • The no-weights finding is from the repository's files and config and a Hugging Face name search. A model could exist under another name or somewhere we did not look.
  • The ACL 2026 Findings venue for TicToc is the authors' own arXiv comment ("ACL 2026 (findings), Camera-ready"); we did not check ACL's list.
  • We do not know whether closed models would close the gap if trained on the same in-domain data. The paper does not test it.
  • The transcript is auto-captioned, so wording may differ from what was said where names were garbled.
  • The video is the host's work. We quote it sparingly and use none of its frames.

Related field notes: Three AI videos mostly got their numbers right. The slip is in what each number is attached to. checks other videos the same way, and Your AI agent is a text predictor in a loop covers why agents lose track of what they were told.

#Sources

All read October 29, 2026, Central time.

Keep reading