Checking Posts Before the Reader Reaches Them: Contention-Aware On-Device Misinformation Labels

Suppose a phone or laptop checks the posts in a social feed for misinformation itself, rather than sending them to a company's servers. The model doing the checking competes with the scrolling interface for the same memory system. If the checker runs flat out, scrolling stutters. If it is throttled hard, the warning label shows up after the reader has already read or shared the post, and a late label is close to useless. This note proposes treating the reader's scroll position as a deadline for each post. The checker would be scheduled and its memory bandwidth regulated so that each label is ready when the post enters view, while the interface still hits its frame deadlines. What the reader sees when a check is unfinished or shallow would be designed with users rather than assumed.

This is worth doing because two literatures each hold one half of the problem and ignore the other. Misinformation detection has moved toward heavy models, including multi-agent language-model reasoning and span-level analysis of partly true articles, without asking where or when they run. Multicore systems research has shown that background work sharing a memory system can slow a time-critical task by orders of magnitude, but it has never treated a human reader's attention as the thing with a deadline. Game-theoretic work on labeling says platforms should honestly show their imperfect verdicts. It treats the detector's error rate as fixed, when on a device the error rate depends on how much compute the checker was allowed before the deadline.

Core Claim

The claim is that label timeliness, label quality and interface smoothness form one coupled resource-allocation problem. It can be solved on commodity hardware by two things together. The first is a scheduler that orders verification work by predicted time-to-view. The second is fine-grained memory-bandwidth regulation of the checker, triggered by frame-deadline pressure on the interface thread rather than by CPU time. The claim can be falsified in three ways. If plain operating-system priorities already remove scroll stutter, the regulation half is unnecessary. If a cloud checker delivers labels before view just as reliably, the on-device premise only matters in a privacy-constrained regime. If users react no differently to "not yet checked" than to no label at all, the design half is unnecessary.

The scheduling objective can be stated simply. For post $i$, let $t_i$ be the predicted time it enters the viewport, estimated from scroll velocity. Let $c_i(b)$ be the finish time of its check under a memory-bandwidth budget $b$. Let $m(b)$ be the rate of missed interface frames under that budget. The scheduler chooses an order and budgets that solve

$$\max_{\text{order},\,b}\ \frac{1}{N}\sum_{i=1}^{N} \mathbf{1}[c_i(b) \le t_i] \quad \text{subject to} \quad m(b) \le \mu,$$

where $N$ is the number of posts in a session and $\mu$ is a tolerated frame-miss rate. In words, it maximizes the fraction of posts labeled before they are seen, without letting the interface drop more than a set share of frames. A cascade extends this. A cheap first-pass verdict is produced for every post, and the deeper span-level check is spent only where time and bandwidth allow. The label then honestly reports which depth of check it reflects.

Research Program

The work has three parts, and the order matters.

Part one: measure the problem. The first step establishes that it exists at all, because the file contains no measurement of interface stutter caused by misinformation-detection workloads. We would run a representative checker cascade alongside a feed-rendering workload. The first pass is a small stance or incongruity classifier; the deep pass is a quantized language model doing span identification. Two edge platforms already used for contention studies would host the runs. One is the NVIDIA AGX Orin used by ROSGuard, a middleware bandwidth regulator that reads hardware performance counters and preempts over-budget work with a high-priority throttle callback. The other is the ZCU102 or i.MX8M boards used by MemPol, which polices per-core bandwidth from a companion core at 6.25 to 10 µs periods with essentially no overhead on the application cores. We would record frame-time distributions, last-level-cache miss rates and memory-controller traffic under four conditions: isolation, unregulated co-running, priority-only co-running and regulated co-running. The motivation comes from the heterogeneous RISC-V system-on-chip of A Reliable, Time-Predictable Heterogeneous SoC, which reports a 225x slowdown of a time-critical task under unregulated DMA interference and recovery of 75% of isolated performance with traffic shaping and cache partitioning. Its AI workloads were matrix multiply and FFT kernels, not language models, and its critical task was an interrupt path, not a user interface. Whether transformer inference produces comparable interference for frame rendering is the first open question. The Interference-free Operating System work, whose merged Linux patches reduced worst-case jitter 8.7x, constrains the design. Some interference comes from the kernel itself, so we would run on a kernel with those patches to separate kernel jitter from memory contention.

Part two: build the scheduler and regulator. The scheduler predicts $t_i$ from scroll velocity and viewport history. It orders checks by deadline and assigns the checker's cores a bandwidth budget. That budget tightens whenever interface frame times approach their deadline. We reuse ROSGuard's counter-driven throttling as the enforcement mechanism on Orin, and MemPol's polling design where a companion core exists. What is new is the control signal: frame-deadline slack plus predicted time-to-view, rather than a fixed per-core budget. The cascade decides per post whether to stop at the first-pass verdict or spend remaining slack on span-level analysis.

The span-level task follows MisSpans, which defines identifying which spans of a partly true article are false, classifying the error type, and explaining it. It found span identification and typing hard, with F1 generally below 0.5 across 15 models, while explanations were easier. That negative result shapes the design: the deep pass cannot be trusted as ground truth, so the label must convey depth and confidence rather than a verdict. The first pass can draw on headline-body incongruity, as in the hierarchical encoder of Detecting Incongruity between News Headline and Body Text. That model compares the headline to each paragraph and flags the worst mismatch, reporting 0.977 AUROC with its paragraph-level method. Its per-paragraph structure also suits incremental, interruptible computation.

Part three: design what users see, then test it. Following the participatory methods summarized in the file, we would first run guided walkthroughs and Wizard-of-Oz sessions with a small cohort. In a Wizard-of-Oz study a human secretly simulates the system's behavior before it is built. These sessions would decide how three states are shown: "not yet checked", "quick check only" and "full check with highlighted spans". The theoretical anchor is Transparent Tagging. It models platform, content creator and users as a persuasion game and proves that honestly disclosing the platform's imperfect veracity signal maximizes creators' effort toward authenticity, with higher error rates strictly reducing that effort. We build on it by making the error rate endogenous: shallower checks have higher error, and the label discloses which regime applied. Whether real readers can use that extra information, or whether it adds cognitive load, is the empirical question the paper leaves open. The file's own open problem on alert fatigue says the answer is not obvious.

The WeNet project, reported in The Theory, Practice, and Ethical Challenges of Designing a Diversity-Aware Platform, ran value-sensitive, participatory design against engagement-maximizing platforms. It warns that reducing nuanced phenomena to rigid categories alienates people. That is a caution against collapsing hybrid articles into binary tags, and it motivates showing spans rather than verdicts. Its living-lab lesson from TISHW points the same way: 62% of health-portal users were unaware of a feature that 81% found useful once shown. A label that exists but arrives late, or goes unnoticed, is a design failure rather than a model failure.

Baselines

Naive reference points. The do-nothing reference is the checker co-running unregulated at default operating-system priority. It gives the unregulated stutter and label-lateness numbers against which everything else is judged. A second naive reference is the interface running with no checker, which sets the ideal frame-time distribution; the target is to stay close to it.

Priority-only scheduling. The checker runs at the lowest scheduling priority, confined to separate cores by standard Linux control groups, on the interference-mitigated kernel from Interference-free Operating System. This is the strongest simple competitor because it is what a practitioner would actually ship. It controls CPU time but not memory bandwidth, so it isolates whether bandwidth regulation is needed at all.

Static bandwidth regulation. This is ROSGuard as published: a fixed per-core bandwidth budget for the checker, enforced by counter-driven throttling. The published overhead and response figures are about 1.06% slowdown at 1 kHz monitoring and activation delay under 200 µs with self-sampling, per ROSGuard. Where a companion core exists we also run MemPol's fixed-budget regulation. These are the strongest existing mechanisms. Our system must beat them on the fraction of posts labeled before view at an equal or lower frame-miss rate. A win on only one axis does not count, since a fixed budget can always be tuned to trade one against the other. We therefore sweep the fixed budget and require our operating point to lie outside the tradeoff curve it traces.

Cloud checker. The same cascade runs on a server, with measured network round-trips on Wi-Fi and cellular connections. It shares the device's labeled-before-view metric and has no local contention.

Detector accuracy reference. For the first-pass classifier, the reference is SC-FNA from An Explainable Fake News Analysis Method with Stance Information, which reports 93.85% accuracy and 93.04% F1 on the FNC-1 stance benchmark. It combines augmentation, a BERT-based stance classifier and propensity-score matching. Our first-pass model need not beat this. We report how far below it the device-feasible model falls, since that gap is the cost the cascade's deep pass must recover.

For span-level work, the reference is the MisSpans result that span identification F1 generally falls below 0.5, per MisSpans. There is no reported result on Lacuna for any detector's span F1 under a latency budget, so we will establish one.

For cross-domain rumor data, RAAR reports the highest average F1 across AMTCele, PHEME and COCO for its 14B multi-agent pipeline, but the file gives no specific number. No reported result is found on Lacuna for a numeric RAAR F1. RAAR serves as the unconstrained accuracy ceiling rather than a device baseline.

Ablations. Two ablations isolate the key ingredients. The first replaces predicted time-to-view with first-in-first-out ordering, keeping bandwidth regulation. The second keeps deadline ordering but uses a fixed bandwidth budget. The claim requires both ingredients to contribute.

Why not just…?

Why not just run the checker at low priority? This is the most serious threat. If a lowest-priority checker confined to its own cores already keeps frame misses near the no-checker level, the regulation half of the proposal is unneeded. The reason to expect it will not be enough is that the interference in the cited systems work is in shared memory and caches, which scheduling priority does not arbitrate. That is the mechanism behind the 225x slowdown in the heterogeneous SoC and the motivation for MemPol. That evidence comes from other workloads, though. Part one of the program measures it directly for language-model inference against rendering. If priority-only wins, we report that and narrow the contribution to deadline-ordered scheduling and label design.

Why not just check posts in the cloud? For users willing to send their feed to a server, this may simply win. It has no local contention and can run much larger models. The file's argument that value-sensitive design makes local execution mandatory overstates what WeNet shows. WeNet motivates caution about centralization, not a proof, so we treat privacy as a scoping assumption rather than a result. The experiment compares labeled-before-view rates for cloud and device checks under measured network latency, including cellular. The on-device case stands only where the privacy constraint binds or where round-trips miss view deadlines.

Why not just always run a tiny model? A small classifier uses little bandwidth and may never cause stutter. Its errors are the problem. Transparent Tagging shows that higher misdetection error strictly lowers the authenticity effort a platform can induce. MisSpans shows that partly true articles are exactly where coarse verdicts mislead. The cascade includes the tiny model as its first pass. The ablation that stops at the first pass for every post measures what the deep pass adds in accuracy and in user decisions. If users act identically on tiny-model labels, the deep pass is not worth its bandwidth, and we will say so.

Why not just show a standard "false" label and skip the design work? A fixed binary label is cheap to build. The design question here is new, though: how to show a check that is unfinished or shallow. No prior design for that state exists to reuse. The controlled study below compares a standard binary label against the co-designed depth-aware label on the same posts.

Proposed Experiments

The systems evaluation replays scroll traces from recruited participants over feeds built from PHEME rumor threads, MisSpans articles and FNC-1 headline-body pairs, on Orin and a MemPol-capable board. The primary outcomes are three: the fraction of posts labeled before entering view, the 99th-percentile frame time and frame-miss rate, and label quality at the depth actually reached. Label quality is F1 against gold labels, and span F1 on MisSpans items. The decisive check is whether the deadline-aware regulated system reaches a labeled-before-view rate above every point on the swept static-budget tradeoff curve, at frame-miss rates no worse than priority-only.

The user evaluation runs in two stages. The participatory stage uses walkthroughs and Wizard-of-Oz sessions with a small cohort and fixes the depth-aware label design. The controlled stage is a between-subjects study with a larger online sample using a simulated feed. It compares no label, a late binary label, an on-time binary label and an on-time depth-aware label with span highlights. Outcomes are the intention to share false posts versus true ones, discernment between the two, and self-reported cognitive load.

The decisive human result is twofold. On-time labels must reduce sharing of false posts relative to late labels, which establishes that timing, and therefore the contention work, matters to people and not only to benchmarks. The depth-aware label must preserve discernment on partly true articles without raising reported load above the binary label. If on-time and late labels produce the same behavior, the link between contention and human outcomes fails, and the proposal reduces to a systems result about co-running language models with interfaces.