Streaming fraud detectors keep a running summary of each card's history, a hidden state updated after every transaction, and compare each new payment against it. That summary is exposed to two opposite failures. If it updates on every event, an attacker who has taken over an account writes their own behavior into the card's "normal" profile, so each later fraudulent payment looks a little more ordinary. If it updates too slowly, a real customer who moves city or changes habits keeps triggering false alarms. Current production systems update the profile immediately. They do so even though the true label of a transaction, fraud or not, typically arrives hours to days later, and even though a second model that sees subsequent activity is much more accurate than the real-time one (The Importance of Future Information in Credit Card Fraud Detection).
We propose to split the card's memory in two. A fast state updates instantly and is used at the authorization gate. A slow, long-term profile absorbs an event only after it has survived a verification delay, and only in proportion to how clean a posterior model, one allowed to look at later transactions, judges it to be. The slow profile then tracks benign preference drift with a known lag and does not learn from events the posterior model finds suspicious. Because consolidation runs off the latency-critical path, the design also makes a two-scale state cheaper to maintain at billion-event scale than making every update richer.
Core Claim
In current streaming fraud models, the step that decides what enters long-term behavioral memory is ungated and immediate. Making it delayed and gated by a posterior model should do two things. It should flatten the "poisoning curve", meaning the detection rate for the n-th fraudulent transaction after an account takeover should stop decaying as n grows. It should also keep false alarms after benign lifestyle shifts bounded by a tunable lag. Both effects should come at essentially no added authorization latency.
Let $s$ be a card's slow profile, $x_i$ an event older than the delay $D$, $p_i$ the posterior model's fraud probability for $x_i$ given the events that followed it, and $u(s, x_i)$ a learned update such as a time-gated recurrent cell. The consolidation rule is
$$s \leftarrow s + (1 - p_i)\, g(\Delta t_i) \odot \big(u(s, x_i) - s\big),$$
where $g(\Delta t_i)$ is a time-lag gate in the style of What to Do Next: Modeling User Behaviors by Time-LSTM. Setting a confirmed fraud label forces $p_i = 1$. The fast state is an ordinary recurrent state that is reset toward $s$ whenever the card is idle.
Relation to Prior Work
Two papers motivate the gap. The first is Interleaved Sequence RNNs for Fraud Detection, which streams a GRU over raw transactions with hidden states kept in an embedded key-value store and beats production LightGBM. It updates its single state on every event, fraudulent or not. The second is Learning Transactional Behavioral Representations for Credit Card Fraud Detection, whose TH-LSTM adds a time-interval gate and attention over past windows. Its history is likewise whatever was observed, with no notion of verified versus unverified.
The Importance of Future Information in Credit Card Fraud Detection supplies our gating signal. It shows that a Bi-LSTM using later transactions reaches AUCPR 0.403 against 0.344 for a history-only LSTM, and it reports that about 70% of cardholders transact again within 24 hours. That paper uses the posterior model only for verification queues. We reuse it to decide what the real-time model is allowed to remember.
The two-scale structure is borrowed from recommendation. Hierarchical Temporal Convolutional Networks for Dynamic Recommender Systems updates a long-term GRU only at session boundaries so that bursts cannot destabilize it. Time Lag Aware Sequential Recommendation fuses short- and long-term states through a learned time gate. Both assume the data are honest. Neither asks whether an event deserves to enter long-term memory, which is the central question once an adversary is present.
The drift literature constrains the design. ADAPT (Customs Fraud Detection in the Presence of Concept Drift) and TBBTS (Adapting to Concept Drift in Credit Card Transaction Data Streams Using Contextual Bandits and Decision Trees) show that greedy detectors fall into confirmation loops, and that population-level drift needs exploration over tabular models. Our proposal targets a different drift, the drift of each card's own baseline, and does not replace exploration. It inherits their warning that the posterior gate can only clean what someone eventually inspects.
Research Program
We will build a two-state streaming detector. The authorization path reads both states from a key-value store, updates only the fast state, and scores the event. A consolidation worker holds a bounded buffer of each card's unconsolidated events. Once an event is at least $D$ old, the worker runs the posterior model over it and its successors, then applies the rule above in batches.
The analysis centers on three questions. The first is how the poisoning curve depends on $D$ and on the gate. The second is how false alarms after benign drift grow with $D$; the expected cost is roughly linear in $D$ multiplied by the rate of benign shifts, since the slow profile lags by $D$. The third is how much of the benefit survives when the posterior model is itself fooled.
The hardest case is "grooming": an attacker makes innocuous-looking transactions for longer than $D$ in order to shift the profile before striking. We treat it as a stress test rather than a solved problem. On systems we measure p99.999 authorization latency, bytes of state per card, and buffer size, which is bounded by $D$ times the per-card event rate.
Baselines
The naive reference is a history-free per-transaction classifier: LightGBM on the raw transaction features, trained chronologically. It shows how much any sequence modeling contributes on each dataset. The pure bandit approach is also a relevant point of comparison: TBBTS reports Precision@K of 0.724 against 0.376 for XGBoost on the ULB data (Adapting to Concept Drift in Credit Card Transaction Data Streams Using Contextual Bandits and Decision Trees).
The strongest practical competitor is LightGBM on hand-built multi-window aggregates (1 hour, 24 hours, 7 days, 30 days). Crucially, we also give it a variant whose long windows aggregate only events older than $D$ and not labeled fraud. That variant is the tabular analogue of our idea. Both variants receive the same features the neural models see and the same hyperparameter-search budget.
The strongest existing sequence methods are the interleaved streaming GRU (Interleaved Sequence RNNs for Fraud Detection) and TH-LSTM (Learning Transactional Behavioral Representations for Credit Card Fraud Detection). TH-LSTM reports average precision 0.880 and AUC 0.944 on a 5.12M-transaction proprietary dataset we cannot access. On MultiMAuS, TBBTS reports the highest cumulative reward but no scalar value, so for MultiMAuS no reported result was found on Lacuna for any sequence baseline. We will therefore rerun all baselines ourselves. Every model uses the same chronological splits, the same parameter count within 10%, and the same tuning trials.
The key ablation holds the architecture fixed and varies only the consolidation rule. The variants are immediate updating, delayed but ungated updating, delayed with confirmed-label gating only, and delayed with posterior-model gating.
Beating the field means two things together. The first is equal or better overall AUCPR. The second is a statistically significant improvement in recall on fraud events five or more transactions after takeover, measured at a fixed false-positive rate. If the delayed-aggregate LightGBM matches us on both, the neural consolidation is not justified.
Why not just…?
Why not just use delayed rolling aggregates in a gradient-boosted model? This is the real threat, and it is why the delayed-aggregate LightGBM appears as a baseline. The evidence against it is indirect. Interleaved Sequence RNNs for Fraud Detection reports about 10% more recall than a profiled production LightGBM on one bank dataset, and fixed windows cannot weight events by posterior suspicion. If the tabular variant captures most of the poisoning benefit, we will report that the gain comes from delay, not from learned memory.
Why not just roll back the state when a fraud label arrives? Rollback repairs only confirmed cases. Under the confirmation trap documented by ADAPT, frauds the system never flagged are never labeled, so their effect on the profile persists. The "confirmed-label gating only" ablation is exactly this alternative. Our claim holds only if posterior gating beats it on unlabeled-in-time fraud.
Why not just add the time gap as an input and retrain more often? Time-aware gating already helps; Time-LSTM lifts LastFM Recall@10 from 0.2451 to 0.3990 (What to Do Next: Modeling User Behaviors by Time-LSTM), and TH-LSTM applies the idea to fraud. Retraining, however, changes the weights, not the per-card states that fraudsters have already written into. The immediate-update, time-gated baseline, retrained on the same schedule, measures whether this matters.
Proposed Experiments
The primary testbed is the MultiMAuS simulator. It lets us inject controlled account takeovers, grooming attacks of varying length, and benign drift episodes such as travel and spending-level shifts, all with known ground truth. We run 25 seeds, matching the TBBTS protocol.
The public ULB dataset has no card linkage, so it serves only as a negative control on which sequence methods should not help. For realism we will seek a chronologically split industrial card stream with user linkage, following the protocols in the interleaved-GRU and future-information papers. We will say plainly if one is unavailable, because the public benchmark landscape is itself one of the scale limitations this work runs into.
The metrics are overall AUCPR, early AUCPR on each card's first fraud, recall at a fixed false-positive rate, money recall, the false-alarm rate in the days after a benign shift, and p99.999 latency.
The decisive checks are three. The first is the poisoning curve: detection rate as a function of the transaction's position after takeover, where immediate-update models should decay and ours should stay flat. The second is the trade-off curve between benign-drift false alarms and $D$. The third is the grooming curve, which locates the attack length at which posterior gating stops protecting the profile.
References
- The Importance of Future Information in Credit Card Fraud Detection
- What to Do Next: Modeling User Behaviors by Time-LSTM
- Interleaved Sequence RNNs for Fraud Detection
- Learning Transactional Behavioral Representations for Credit Card Fraud Detection
- Hierarchical Temporal Convolutional Networks for Dynamic Recommender Systems
- Time Lag Aware Sequential Recommendation
- Customs Fraud Detection in the Presence of Concept Drift
- Adapting to Concept Drift in Credit Card Transaction Data Streams Using Contextual Bandits and Decision Trees