SEER is a closed-loop forecasting agent that turns each prediction error into two text updates: a memory telling it what to search for next time, and a causal rulebook telling it how events move the target. The frozen LLM then forecasts over an evolving textual context, not just numbers.
You’re forecasting something that keeps getting whacked by exogenous shocks: DRAM prices after a fab outage, electricity demand during a heat wave, a stock after an earnings surprise. Pure numerical forecasters, including Time Series Foundation Model like TimesFM 3.0 and Chronos-2, only see the historical series. They miss the news that actually drives the next move.
The obvious fix is Retrieval-Augmented Generation: pull in news articles alongside the numbers. The paper argues this fails in three ways for forecasting. News streams are mostly noise, semantic similarity is not causal attribution, and a one-shot retrieval never learns from being wrong. So the baseline the paper really wants to beat is “LLM + Event RAG”: the same backbone LLM, same news corpus, no feedback loop.
The backbone LLM is frozen. SEER improves forecasts by improving the text that gets handed to the model, not its weights. Two separate text stores are maintained and updated after every training-window forecast:
•
A reflective retrieval memory splits into a retrieval half (what queries to run, what signals were missing last time) and a selection half (what kinds of articles were noise and should be filtered).
•
A persistent causal knowledge base holds plain-language IF-THEN rules distilled from past errors (e.g., for memory chips, an “upside squeeze” regime with specific multipliers).
At each training step the agent forecasts, observes the true outcome, then runs two reflection prompts. One updates the retrieval/selection memory, the other updates the causal rules. A separate condensation operator merges duplicates when a store crosses roughly 80% of its character budget. Crucially, everything is indexed by time: reflections and retrieved events are capped at the forecast cutoff using the fact-checking filter from LEAF, so the agent cannot peek at the future it is predicting. At test time, both stores are frozen and only inference runs.
for t in training_cutoffs:
events = search(x_t, cutoff=t) # 2 generic rounds
events += guided_search(x_t, M_ret, cutoff=t) # memory-driven round
events = filter_noise(events, M_sel)
y_hat, reasoning = LLM(x_t, events, K) # frozen backbone
observe(y_true)
M_ret, M_sel = reflect_memory(trajectory, M) # what to seek/skip
K = reflect_knowledge(trajectory, K) # causal rules
M, K = condense_if_full(M, K)
Across six event-driven domains (DRAM and SSD prices, US weather, US electricity load, 50 US stocks for next-day direction, and a Polymarket event-probability subset from ForecastBench), SEER with a Claude Opus 4.8 backbone beats 15 numerical and LLM-based forecasters plus the “LLM + Event RAG” baseline.
•
On Memory 6-month price forecasting, SEER cuts MSE by 50.2% versus the best baseline, and MAE by 16.5%. The paper reads the larger MSE drop as evidence SEER avoids the big misses during regime shifts.
•
At the 9-month horizon, where numerical autocorrelation is weakest, SEER cuts MSE by 24.3% on Memory and 19.6% on SSD versus the best deep baseline.
•
Ablations across four backbones (Claude Opus 4.8, Claude Sonnet 4.6, Gemini 3.1 Pro, Gemini 3.1 Flash) show the full SEER averages +10.5% (Opus) and +11.4% (Flash) over the same backbone with plain event RAG. Memory-guided retrieval alone (no causal rulebook) helps unevenly; adding the rulebook is what makes gains consistent.
•
A pairwise LLM-as-a-Judge rating by Grok-4.20-Reasoning, scoring reasoning quality while hiding the numeric ground truth, prefers full SEER over Event RAG 55.6% of the time versus 16.9% losses, aggregated across backbones.
•
On Selective Stock Forecasting, where the agent picks at most six of 50 stocks per day, SEER and the Event RAG baseline score similarly on their 29 overlapping picks (51.7% vs 48.3%), but SEER’s distinct 43 picks hit 51.2% versus the baseline’s 32.7%, suggesting the gain comes from better abstention, not better pointwise prediction.
Two important observations about scope. The forecaster is evaluated on a backtest with chronologically frozen memories at test time, not in true live deployment. And the “causal” rules are LLM-written natural-language heuristics, not formally verified causal structure.
•
If you run a forecasting system that already pipes news into an LLM, the lift here is attributable to the feedback loop, not the retrieval. Worth testing: add a per-error reflection step that writes to a persistent prompt file, and compare against your current static-RAG setup on your own backtest.
•
Keep the two reflection channels separate. The paper’s ablation shows that memory-guided retrieval alone is inconsistent across backbones; the causal-rules store is what pulls gains into the positive range reliably. If you only build one, build the rules.
•
Chronological hygiene is doing real work. If you adopt this pattern, you need a dated event source and a fact-checking filter equivalent to LEAF; otherwise your “reflection” will leak future information into past training steps and your backtest will overstate gains.
•
Treat the selective-stock result as a lesson about abstention, not stock picking. The useful decision is: when your model can refuse to predict, learned rules about when to abstain may matter more than tweaking the pointwise forecaster. Code is at GitHub. The paper does not isolate how much of the gain comes from the extra guided search round versus the causal rules; the ablation compares whole configurations. The condensation step is prompted compression by an LLM, so the stored rules can drift or lose nuance over long training runs, and the paper does not quantify that drift. Stock accuracy numbers hover in the mid-to-high 30s on a three-way Up/Neutral/Down label, so “beats baseline” is not “profitable.” All backbones evaluated are large frontier models from two vendors; whether the same loop helps a small open-weights model is untested here. Finally, test-time memories are frozen, meaning the “self-evolving” property is confined to the training window and does not continue adapting during the evaluation period reported.