acceptodds
Under review as a conference paper at ICLR 2027

Guarding a Needle in the Haystack: A Real-Time Policy-Following Streaming Video Guardrail

Abstract

With the rapid growth of video generative models, robust guardrails are more critical than ever to ensure both video content safety, which prevents the proliferation of harmful material (e.g., sexual or self-harm), and video generation security, which defends against adversarial attacks on video generation models (e.g., jailbreak prompts or unsafe video injection). While recent multimodal large language model (MLLM) based guardrails have advanced through reasoning and video understanding, they still face significant limitations. In particular, they rely on frame subsampling, which is unreliable for precise long-term monitoring. In addition, they lack support for real-time streaming and incur high overhead due to inefficient token usage. To address these challenges, we propose StreamGuard, the first real-time, policy-following streaming video guardrail. To precisely identify the few unsafe frames hidden among many benign ones, StreamGuard efficiently inspects the input video in streaming form to localize unsafe content with high precision. To enable real-time streaming, StreamGuard employs an efficient asynchronous inference stack that parallelizes safety analysis across ingested events while simultaneously encoding and detecting incoming frames, achieving fine-grained, frame-level monitoring with low latency. In addition, considering the lack of benchmarks that reflect real-world video safety risks, we introduce two benchmark datasets that include: (1) Safe2Shot, with 5K short videos annotated with frame-level unsafe spans, capturing needle-in-the-haystack cases where harmful content appears in only a few frames; and (2) AdvVideo-Bench, which includes both TV2V and TV2T components targeting the video and text modalities respectively, designed to evaluate guardrail resilience against video-centric multimodal jailbreaks. Extensive experiments show that StreamGuard outperforms the strongest baselines by 7.0 and 6.0 accuracy points on TV2T and TV2V, improves video-level F1 by 1.7 points on Safe2Shot, and achieves the best F1 on four of six existing public benchmarks, while cutting end-to-end latency by 46.1% via parallel event-level inference.

Primary area:
alignment, fairness, safety, privacy, and societal considerations
Keywords:
video guardrail, content moderation, streaming video understanding, multimodal large language models, safety, adversarial robustness, jailbreak, benchmark

Reviews

Among:
Shape:
1234this paper, Top 30%
Figure 1. Mean review rating of the reviewed papers at ICLR 2027. This paper averages 2.67 over 3 reviews, above 70% of the others.
Reviewer_3rMJOpenReview ↗
Rating
2
Confidence
3
Informativeness
2
Presentation
3
Soundness
1
Read review
Paper summary

This paper proposes StreamGuard, a real-time, policy-following video guardrail that combines streaming frame-level detection, event-level summarization, parallel inference, and multi-level policy alignment. The authors also introduce two benchmarks, Safe2Shot and AdvVideo-Bench, to evaluate fleeting unsafe content and adversarial robustness. Experiments demonstrate improvements in detection performance and inference efficiency.

Critical strengths
  • Important and practical problem. The paper addresses real-time video safety monitoring, particularly the detection of short-lived unsafe content that conventional frame-sampling approaches may miss.

  • Interesting streaming architecture. StreamGuard combines frame-level detection, event-level reasoning, and asynchronous parallel inference to improve detection efficiency.

Critical weaknesses
  • Inconsistent frame-exact coverage claim. The paper claims frame-exact coverage without sampling loss, but StreamGuard processes videos at only 2 FPS. Consequently, unsafe events lasting less than 0.5 seconds may still be missed, contradicting the motivation of detecting fleeting unsafe content.

  • Potentially unfair frame-budget comparison. StreamGuard processes videos at 2 FPS, while other baselines receive only 16 uniformly sampled frames. Appendix B.2 shows that StreamGuard's performance decreases substantially under the same 16-frame budget, raising concerns about the fairness of the comparison.

  • Unclear computational overhead of parallel inference. The reported inference speedup relies on multiple parallel workers, but the paper does not clearly specify whether additional GPU resources are required. GPU utilization, memory consumption, and efficiency under fixed hardware budgets should be evaluated.

  • Limited cross-generator generalization. The paper does not sufficiently evaluate whether StreamGuard generalizes to unsafe videos produced by different video generation models. A leave-one-generator-out evaluation would strengthen the generalization claim.

  • Potential dependence on attack-specific training distributions. TV2T and TV2V use similar attack construction pipelines for training and testing. The reported robustness improvements may therefore reflect learned attack-specific patterns rather than generalization to unseen attacks.

  • Insufficient evaluation of policy-following robustness. The improvements may largely result from adversarial training rather than stronger policy-following capabilities. More evaluations on unseen safety policies and separate visual-obfuscation and prompt-injection attacks are needed.

Questions for authors
  • Frame coverage. How does StreamGuard handle unsafe events shorter than 0.5 seconds when processing videos at 2 FPS?

  • Comparison fairness. Could the authors compare StreamGuard with baselines under identical frame and computational budgets?

  • Inference efficiency. Does parallel inference require additional GPUs, and how does the speedup change under a fixed GPU budget?

  • Cross-generator generalization. How well does StreamGuard detect unsafe videos generated by unseen video generation models?

  • Unseen adversarial attacks. Could the authors evaluate robustness against attack templates and transformations not included in training?

  • Policy-following robustness. How much of the improvement comes from policy alignment rather than adversarial training?

4 comments

Response to Reviewer 3rMJ (Part 1/3)

We thank the reviewer for the detailed and critical review. We understand the core concern to be that the gains might come from more frames and in-distribution adversarial training rather than from the method itself. We address each point below with existing controlled results and new experiments, several of which are shared with other reviewers (General Response G1–G3).

W1 / Q1. Events shorter than 0.5 s at 2 FPS. The reviewer is right that “frame-exact coverage without sampling loss” overstates what a 2 FPS system does; we have replaced it with “dense, uniform-rate coverage of every ingested frame.” Three clarifications:

  • Safe2Shot annotations have 1-second precision, so at 2 FPS every annotated unit is covered by at least two frames. Sub-0.5 s events are not represented in the current benchmark, and we now state this limitation explicitly in the new Limitations section.
  • The frame rate is a deployment parameter. Appendix B.2 shows that 4 FPS adds only +1.0 Acc, and the cost scales linearly. By comparison, 16 uniformly sampled frames on a 1-minute video means one frame every 3.75 s, versus every 0.5 s for StreamGuard.
  • Event-level recall by span duration, including the shortest annotated spans (1 s), at 1, 2 and 4 FPS will be added in the final version (see bhbp-W1).

W2 / Q2. Identical frame and compute budgets (G1). We should not have described the 16-frame result in B.2 as "comparable": at 16 frames StreamGuard is below GPT-4.1, as one would expect from an 8B model. The comparison we argue for is at matched cost. StreamGuard reads the full 2 FPS stream in 3.97 s (2.14 s parallel), below every 16-frame baseline in Table 7, including its same-size base model InternVL3-8B (4.05 s). This shows that dense coverage comes from the streaming design, not from model size. On identical frames it leads the best baseline by 3.1 frame F1. Open baselines at 32/64 frames and the full accuracy–latency frontier will be added in the final version.

Response to Reviewer 3rMJ (Part 2/3)

W3 / Q3. Do parallel workers need extra GPUs? Not in any experiment reported in the paper, but in the current implementation, yes, beyond four concurrent summaries. All latency numbers in the paper (Table 7, Figure 3) were measured on a single NVIDIA H100. In that implementation, one labeling process holds the full model, and summary workers are separate processes on the same GPU, allocated on demand when an event enters its explanation phase. Each summary worker holds its own copy of the weights, so memory grows by roughly 15 GiB per active worker. The measured peak GPU memory (nvidia-smi), reached with the labeling process plus 4 concurrent summary workers, is 79 GB, close to the 80 GB capacity of the H100. The “unlimited workers” curve in Figure 3 corresponds to this on-demand policy, i.e., the “sufficient workers” case of Eq. (9). In practice at most 5 processes (1 labeling + 4 summary workers) were ever active at once, including for the "unlimited workers" curve in Figure 3, which is measured rather than simulated: events are short (4.36 frames on Safe2Shot, 14.63 on the B.7 livestreams), so a worker becomes idle as soon as its summary is finished. In the Table 7 run (2.14 s), between 2 and 5 processes were active at a time (1 labeling + 1–4 summary workers).

With 4 summary workers the GPU is nearly full, so if a fifth concurrent summary were needed, the current implementation would place it on an additional GPU. This did not occur in any reported experiment, but it does mean the multi-process design does not scale to higher concurrency (e.g., several streams per GPU) on one card. We agree that per-process model copies are memory-inefficient, and the structure of StreamGuard allows a leaner design in which a worker is a KV-cache sequence slot on a single copy of the weights, served with continuous batching:

  • Closure precedes the summary. An event is closed as soon as a frame label is emitted without <continue> (Appendix A.3), before the summary is generated, so the next event can start immediately without speculative execution.
  • No copying. The summary keeps decoding in the closing event’s slot; the next event opens a new slot.
  • Shared prefix. Every event restarts from the same policy header H(P, q) (§3.2), whose KV cache is computed once and shared across events and streams, so starting an event costs no prefill.
  • Small, short-lived state. With the InternVL3-8B base model, whose LLM is Qwen2.5-7B (28 layers, 4 KV heads, head dim 128, fp16), KV is about 56 KB per token; an event context is about 1,100–1,400 tokens (about 80 MB) on Safe2Shot and about 4,000 tokens (about 220 MB, 14.63 frames per event) on the B.7 livestreams, and it is released once its summary is done. Hundreds of slots fit on one GPU.

Summary decoding and the next event’s labeling are merged into the same forward passes. Because decoding is memory-bandwidth bound, the per-step cost grows only slowly with batch size.

We are implementing this single-copy design, and in the final version we will compare it with the multi-process implementation on the same H100 (latency, throughput and peak memory). We now state the hardware configuration in a new appendix section and the memory cost of the current multi-process design as a limitation.

Response to Reviewer 3rMJ (Part 3/3)

W4 / Q4. Unseen video generators. TV2V samples in AdvVideo-Bench are produced by three generators: CogVideoX (474), Wan 2.1 (912) and Cosmos (514), 1,900 in total. The phrase “we fix a generator G” in Appendix A.7 describes the per-sample procedure and was misleading; we now name all three generators in §4.2 and A.7. This makes a leave-one-generator-out evaluation possible: retrain without one generator, test on all of its videos (474 / 912 / 514), and compare with a control that removes the same number of randomly chosen TV2V videos, so that the gap isolates the cost of an unseen generator. We will add this in the final version. In the meantime, the MCV and SPTV results (response to egus-W3) show StreamGuard's behavior on attack videos built entirely outside our data pipeline.

W5 / Q5. Unseen attack templates and transformations. We agree that the original TV2T/TV2V test sets are in-distribution, as noted in §5.1, and that AutoDAN (B.6) is not truly unseen because AutoDAN-style data appear in training. We therefore evaluate on two attacks from other authors whose construction pipelines are absent from our training data: SPTV (CVPR 2026) and MCV (ACL 2026), using their public releases. StreamGuard misses 19.6% of SPTV attacks and 23.4% / 34.4% of explicit / implicit MCV attacks, rising to 27.5% / 40.0% for 4-clip attacks (details in the response to egus-W3). Leave-one-out retraining over TV2T transformation families and TV2V template families will be added in the final version.

W6 / Q6. Policy alignment vs. adversarial training. Table 4 separates the two factors on AdvVideo-Bench. Removing the adversarial data costs 10 points on both TV2T and TV2V (76.0 → 66.0, 68.0 → 58.0). On these in-distribution attacks the adversarial data is therefore the main source of robustness, and without it StreamGuard would fall below SafeWatch (69.0 / 62.0). Policy alignment contributes on top of it: with the adversarial data kept, removing GRPO costs 4.0 / 5.0 points, and replacing the structured policy with a simple prompt costs 2.0 / 4.0 points. On attacks built outside our data pipeline (MCV, SPTV; response to egus-W3), StreamGuard still flags most attack videos. We will add the full 2×2 ablation, evaluated on these unseen attacks, in the final version.

Thank you again for your critical and constructive review. As the discussion period is coming to an end, we would like to check whether our responses have addressed your concerns, in particular those about soundness. In brief:

Frame-exact claim (W1). The wording has been corrected to "dense, uniform-rate coverage of every ingested frame", and sub-0.5 s events are listed as a limitation (Appendix C). Frame budget fairness (W2). At matched cost, StreamGuard reads the full 2 FPS stream faster (3.97 s serial, 2.14 s parallel) than every baseline reads 16 frames. This includes its same-size base model InternVL3-8B (4.05 s), so the gain comes from the streaming design and not from more compute. The inaccurate "comparable" description in Appendix B.2 has been corrected. GPU resources (W3). All latency results are measured on a single H100 with at most four concurrent summary workers (peak 79 GB). The configuration and its memory cost are stated in Appendix A.11 and Appendix C. Generators and unseen attacks (W4/W5). The three TV2V generators are now named in §4.2 and Appendix A.7. Appendix B.9 (Table 18) adds an evaluation on two external video jailbreaks, MCV and SPTV, whose construction pipelines are absent from our training data. Policy alignment vs. adversarial training (W6). We now state explicitly in §5.5 that the adversarial data is the main source of robustness on the in-distribution attacks; policy alignment adds 2–5 points on top of it. We would be glad to answer any remaining questions before the discussion closes. If our responses address your concerns, we would be grateful if you would consider revisiting your soundness assessment and score.

Reviewer_bhbpOpenReview ↗
Rating
2
Confidence
3
Informativeness
2
Presentation
3
Soundness
2
Read review
Paper summary

This paper presents StreamGuard, a real-time, policy-following streaming video guardrail. It combines frame-level safety labeling, self-delimited event summarization, and asynchronous event-level inference to support fine-grained video monitoring.

Critical strengths

1 The authors also introduce two benchmarks: Safe2Shot for fleeting unsafe content and AdvVideo-Bench for multimodal adversarial attacks. Experiments show improvements over existing guardrails on the proposed and public benchmarks, along with a 46.1% reduction in end-to-end latency through parallel inference.

2 The event-level parallel inference design overlaps explanation generation with subsequent frame processing, reducing inference latency by 46.1%. This is a useful system-level contribution toward efficient streaming video moderation.

3 Safe2Shot targets fleeting unsafe content, while AdvVideo-Bench evaluates multimodal adversarial robustness. The evaluation covers both new and existing video safety benchmarks, with comparisons against general-purpose MLLMs and dedicated guardrails. These benchmarks provide useful resources for studying video safety.

Critical weaknesses

1 As emphasized by the paper's title and motivation, a central goal "guard a needle-in-the-haystack" is to detect fleeting unsafe events hidden among predominantly benign video content. However, the evaluation relies mainly on aggregate video-level and frame-level classification metrics. While informative, these metrics do not directly establish how reliably the model detects individual short-duration unsafe events or how accurately it localizes their temporal boundaries.

2 The paper demonstrates efficiency improvements through parallel event-level inference and includes an evaluation on long-form livestreams. These are useful results. However, the reported measurements primarily characterize inference latency and aggregate detection performance, rather than the actual delay between the occurrence of an unsafe event and its first detection. This limits the evidence for timely moderation in continuous streams.

3 Although the visual context is reset at each event boundary, Eq. (6) concatenates frame-level labels and event summaries from all events into the final prompt. Consequently, the final-stage context still grows with stream duration. It is unclear how this stage handles the 30-minute-to-3-hour livestreams evaluated in Appendix B.7, particularly regarding context limits and computational or memory requirements.

Questions for authors

1 How are the frame-level and event-level SFT targets constructed, and how is event granularity determined?

2 The model autonomously determines event boundaries by emitting <summary> to close an event. However, the paper does not sufficiently explain how the corresponding supervision is constructed from the available annotations.

3 The proposed approach resets the visual context at each event boundary, while the final stage aggregates textual frame labels and event explanations. However, it is unclear whether these representations preserve sufficient visual and temporal information for reasoning across independently processed events.

4 Could the authors clarify the evaluation metrics reported in Table 6? Several reported video-level Accuracy, Recall, and False Positive Rate (FPR) values appear inconsistent under standard binary classification definitions.

4 comments

Response to Reviewer bhbp (Part 1/3)

We thank the reviewer for recognizing the parallel-inference design and the two benchmarks, and for the precise questions. The reviewer’s central point, that a “needle-in-the-haystack” claim needs event-level and timing evidence and not only aggregate classification, is well taken. Below we give the evidence available now and state what the final version will add.

W1. Event-level detection and temporal localization. We agree that video-level classification alone does not show that short events are caught. The closest existing evidence is the frame-level evaluation (Table R1). StreamGuard labels every ingested frame and has the best frame-level F1 (76.9). It recovers 85.6% of unsafe frames at a 24.6% false-positive rate; GPT-4.1 and GPT-5 reach slightly higher recall (89.9 / 86.2) only at 40.0% / 31.5% FPR. Because Safe2Shot spans are annotated at 1-second resolution, an event-level evaluation is possible: event recall (a span counts as detected if any frame inside it is flagged), temporal IoU and onset/offset error, bucketed by span duration (1 s, 2 s, 3–5 s, >5 s). We will add this analysis for StreamGuard and the frame-level baselines in the final version.

W2. Delay between an unsafe event and its first detection. Because StreamGuard emits a label for every ingested frame, an alert can be raised as soon as the first unsafe frame is labeled, without waiting for the event or the video to end. On the system side, Figure 3 shows that parallel event-level inference brings the average per-frame latency below 0.5 s, i.e., within the 0.5 s interval between frames at 2 FPS, so labeling keeps pace with the stream on average. In their video-level mode (16 sampled frames), offline baselines judge a clip only after it ends, so their detection delay is lower-bounded by the clip length. We will add the media-time delay from the onset of each annotated unsafe span to its first unsafe label (median and p95) in the final version.

W3. Growth of the final-stage context on long streams. The reviewer is right that Eq. (6) concatenates labels and summaries from all events, so the final prompt grows linearly with duration: at 2 FPS and about 4.36 frames per event, a 3-hour stream has roughly 5,000 events. In our implementation the final prompt is assembled with four length controls that were not described in the submission; we have added a pointer in §3.1 and a new appendix section describing them: (i) consecutive identical frame labels within an event are merged into a single run; (ii) if the prompt exceeds the 32K context, frame labels are dropped and only the event explanations are kept, since each explanation already states that event’s safe/unsafe judgment and category; (iii) if it still exceeds 32K, runs of consecutive safe events are merged by a fixed rule into one segment, represented by a one-line note that the span is safe plus the explanations of its first and last events (no additional model inference), while every unsafe event keeps its own explanation. (iv) If the final prompt would still exceed 32K after (i)–(iii), ingestion stops once an unsafe event has been closed, and the final stage runs on the events seen so far. Steps (iii) and (iv) do not affect the verdict, because the video-level decision depends only on whether any unsafe event exists. Step (iii) merges only safe events. After (iii), runs of safe events take only a few lines, so the prompt can exceed 32K only through individually kept unsafe-event explanations. Step (iv) is therefore reached only after an unsafe event has been found, when the verdict is already unsafe. The cost of (iv) is that the final explanation and reported categories cover the stream only up to that point; unsafe content of a different category appearing later is not described. This matches online moderation, where a stream is acted on at its first confirmed violation. On the B.7 livestreams, events average 14.63 frames (about 7.3 s at 2 FPS); a 3-hour stream therefore has roughly 1,500 events, which is why (ii) and (iii) are needed. All 20 streams trigger both (ii) and (iii). None reaches (iv), so every stream is processed to the end. The longest stream has 1,176 events (985 safe, 191 unsafe), and after merging its final prompt is about 23K tokens, within the 32K context.

We also note that, in online moderation, alerts are raised from frame-level labels as frames arrive; the final stage produces the overall verdict and explanation and is not on the alerting path.

Response to Reviewer bhbp (Part 2/3)

Q1 / Q2. Construction of frame- and event-level SFT targets and of the <summary> boundary. (i) Frame labels: each 2 FPS frame inherits the label of the 1-second Safe2Shot span it falls in. (ii) Event boundaries: taken from the human-annotated shot boundaries that both Shot2Story and Safe2Shot provide, so each annotated shot forms one event; at each boundary a <summary> token and the event-level target are inserted, so the model learns to close events from these supervised positions. (iii) Event-level target: the explanation of each event is written by human annotators and states the event's safe/unsafe verdict; for Shot2Story videos, the safety verdicts and explanations were annotated by our annotators. We have added this procedure as a new appendix section (events average 4.36 frames, B.3).

Q3. Information lost by resetting visual context at event boundaries. Visual information is not discarded before it is used. Each event's explanation is generated while the event's frames are still in context, conditioned on both its frame-level labels and the frames themselves, so the visual evidence of the event is distilled into text before the context resets. The final stage then reasons over these labels and explanations. Consistent with this, Table 12 shows that removing the event-level branch costs only 0.8 F1, whereas removing the frame-level branch costs 11.5 F1 (88.50 → 76.99), which suggests that the verdict is driven mainly by per-frame evidence that the text labels preserve; removing the frame-level branch also removes the input that event-level reasoning builds on. We acknowledge that this does not test reasoning that genuinely spans events, and we have added this to the new Limitations section.

Q4: Inconsistency of Acc / Pre / Rec / FPR in Table 6

We thank the reviewer for checking the numbers carefully. You are right: Table 6 was internally inconsistent. We traced it to an error in how the metrics were aggregated and have recomputed every Safe2Shot number from the raw predictions, using a single script under one fixed protocol.

Cause. Safe2Shot is a binary task in which borderline counts as safe. When the appendix table was recomputed for the supplementary experiments, two errors entered the script. (i) Accuracy was computed under a 3-class scheme that treated the borderline annotation as a separate class. (ii) Precision and recall were computed by a multi-class routine that did not expect some of the annotation label values. As a result, part of the false negatives were counted as false positives. TP and the total number of errors (FP + FN) were unaffected. F1 and FPR were computed separately from the correct binary counts. Because F1 = 2TP / (2TP + FP + FN) depends only on TP and the total number of errors, the video-level F1 values in the submission were correct, and the recomputed values match them to within 0.1. Precision was underestimated and recall overestimated.

At frame level, the error was in the ground-truth labels. Claude-Opus-4.6, Llama-Guard-3-11B-Vision and SafeWatch were evaluated in a separate batch that used an incorrect frame-label file. In that file the share of unsafe frames was about 48% instead of 40%, which inflated these baselines' precision. All other models, including StreamGuard, were evaluated with the correct labels. We recomputed every frame-level result from the raw predictions with the corrected labels. These three baselines drop by 3.3–4.1 F1, and all other rows change by at most 0.5 F1.

Protocol (now stated explicitly in §5.1). Positive = unsafe; negative = safe ∪ borderline. Video-level: one sample per test video, 1,000 videos in total (620 positive / 380 negative). Frame-level: every frame that StreamGuard ingests from the same 1,000 videos is one sample, 31,467 frames in total (12,587 positive / 18,880 negative). Baselines classify each of these frames independently (one frame per query, no shared context); StreamGuard labels the same frames within its stream. All metrics are micro-averaged from a single confusion matrix per model and per split.

Response to Reviewer bhbp (Part 3/3)

Corrected results. Table R1 gives the recomputed Table 6 and Table R2 the underlying confusion matrices (positive = unsafe; borderline counts as safe; video: 620 positive / 380 negative; frame: 12,587 / 18,880).

Table R1. Corrected Table 6 on Safe2Shot (V = video level, F = frame level).

ModelV-AccV-PreV-RecV-F1V-FPRF-AccF-PreF-RecF-F1F-FPR
GPT-569.678.470.374.131.675.664.686.273.831.5
GPT-4.165.773.569.871.641.172.060.089.972.040.0
O4-mini67.888.255.568.112.176.476.858.666.511.8
Gemini-2.5-Flash67.382.659.869.420.575.269.368.468.820.2
Claude-Opus-4.668.580.664.871.825.572.864.969.567.125.1
InternVL3-8B42.891.48.515.61.362.481.77.714.11.2
Qwen2.5-VL-7B38.3100.00.51.00.060.1100.00.20.50.0
Llama-Guard-3-11B-Vision61.375.855.263.928.767.158.759.659.227.9
SafeWatch72.382.570.275.924.276.468.476.372.123.4
StreamGuard73.982.873.177.624.779.569.985.676.924.6

Table R2. Confusion matrices, TP / FP / TN / FN.

ModelVideo (n = 1,000)Frame (n = 31,467)
GPT-5436 / 120 / 260 / 18410,845 / 5,952 / 12,928 / 1,742
GPT-4.1433 / 156 / 224 / 18711,315 / 7,545 / 11,335 / 1,272
O4-mini344 / 46 / 334 / 2767,372 / 2,223 / 16,657 / 5,215
Gemini-2.5-Flash371 / 78 / 302 / 2498,609 / 3,814 / 15,066 / 3,978
Claude-Opus-4.6402 / 97 / 283 / 2188,748 / 4,735 / 14,145 / 3,839
InternVL3-8B53 / 5 / 375 / 567974 / 218 / 18,662 / 11,613
Qwen2.5-VL-7B3 / 0 / 380 / 61731 / 0 / 18,880 / 12,556
Llama-Guard-3-11B-Vision342 / 109 / 271 / 2787,505 / 5,276 / 13,604 / 5,082
SafeWatch435 / 92 / 288 / 1859,599 / 4,425 / 14,455 / 2,988
StreamGuard453 / 94 / 286 / 16710,770 / 4,640 / 14,240 / 1,817

Impact on conclusions. The main claims hold. StreamGuard has the best F1 and Acc at both levels: video F1 77.6 vs. 75.9 (SafeWatch, second best); frame F1 76.9 vs. 73.8 (GPT-5, second best). The precision/recall profile of StreamGuard at video level differs from the original appendix: it is now 82.8 / 73.1, i.e., precision-leaning rather than recall-leaning; at frame level it remains recall-leaning (69.9 / 85.6). We have stated this in Appendix A.5.1. The video-level F1 ranking, on which our claims rest, is unchanged. Several frame-level baseline F1 values in Table 2 also change, by up to 4.1 points (Claude-Opus-4.6 71.2 → 67.1). We have updated Table 2 and Table 6 accordingly and added the confusion matrices above to the appendix (changes in blue).

Thank you again for your detailed review. As the discussion period is coming to an end, we would like to check whether our responses have addressed your concerns. In brief:

Table 6 inconsistency (Q4). We found the cause of the error and recomputed every Safe2Shot result from the raw predictions. Table 2 and Table 6 are corrected in the revised PDF, and the full confusion matrices are in Appendix B.10 (Table 19). The video-level F1 ranking and our main conclusions are unchanged. Final-stage context on long streams (W3). Appendix A.10 describes the four length controls. On all 20 livestreams the final prompt stays within the 32K context (at most about 23K tokens), and every stream is processed to the end. SFT targets and <summary> supervision (Q1/Q2). Appendix A.9 describes how they are built from the human-annotated shot boundaries and event explanations. Cross-event information (Q3). This is discussed with the Table 12 ablation and listed in the new Limitations section (Appendix C). Event-level localization and detection delay (W1/W2). We will add event recall, temporal IoU and the media-time detection delay in the final version. If anything remains unclear, we would be glad to clarify before the discussion closes. If our responses resolve your concerns, we would be grateful if you would consider updating your assessment.

Reviewer_egusOpenReview ↗
Rating
4(+1)
Confidence
3
Informativeness
2
Presentation
2
Soundness
2
Read review
Paper summary

This paper proposes StreamGuard, a policy-following streaming video guardrail designed to detect fleeting unsafe content while reducing inference latency. The framework combines frame-level safety classification, event-level summarization, and parallel event inference to support efficient video moderation.

Critical strengths
  1. Strong empirical performance. The authors evaluate StreamGuard across multiple public benchmarks and introduce two additional datasets covering fleeting unsafe events and adversarial scenarios. The parallel event-level inference mechanism also demonstrates measurable efficiency improvements and inference latency reduction.
  2. Practical significance. The paper addresses an important limitation of existing video safety guardrails, where sparse frame sampling may overlook short-lived harmful content.
Critical weaknesses
  1. Potentially unfair baseline comparisons. According to Section 5.1, existing baselines process 16 uniformly sampled frames per video, whereas StreamGuard operates at 2 FPS and may process substantially more frames. This difference in the input frame budget makes it difficult to determine whether the performance improvements originate from the proposed architecture or simply from increased temporal coverage.
  2. Limited evidence supporting zero-shot policy generalization. The paper claims that StreamGuard can adapt to new safety policies without task-specific fine-tuning. However, the main evaluation in Table 3 focuses on Borderline/Erotic content, which is closely related to the sexual content categories and ambiguous examples already present in the training data. Consequently, this experiment may not adequately demonstrate generalization to genuinely unseen policy concepts.
  3. Insufficient evaluation against video-specific jailbreak attacks. The paper lacks evaluation against representative video-specific jailbreak methods, such as VideoJail [1] and SPTV [2], which exploit vulnerabilities associated with the video modality and temporal composition. Although these attacks target unsafe text generation rather than video moderation directly, adapting them to the guardrail evaluation setting would provide valuable evidence of robustness against more diverse video-based adversarial strategies.

[1] VideoJail: Exploiting Video-Modality Vulnerabilities for Jailbreak Attacks on Multimodal Large Language Models. ICLR Workshop 2025.

[2] Breaking Multimodal LLM Safety via Video-Driven Prompting. CVPR 2026.

Questions for authors
  1. According to weakness 1, could the authors provide a fair comparison in which StreamGuard and the baselines are evaluated under the same frame budget or comparable computational budgets? This would help clarify whether the reported improvements primarily stem from increased temporal coverage or the proposed architecture.
  2. According to weakness 2, could the authors evaluate StreamGuard on genuinely unseen safety policies that are semantically distinct from the categories used during training? Such experiments would provide stronger evidence for the claimed zero-shot policy generalization capabilities.
  3. According to weakness 3, could the authors evaluate StreamGuard against representative video-specific jailbreak attacks, such as VideoJail [1] and SPTV [2], under an appropriately adapted guardrail evaluation setting? This would help determine whether the proposed method generalizes to diverse video-based adversarial strategies beyond those considered in the current experiments.
1 comment

Response to Reviewer egus

We thank the reviewer for the positive assessment of the empirical results and of the practical significance of the problem. We address all three concerns below with existing results and new experiments; details are in the General Response.

W1 / Q1. Same frame or compute budget (G1). We agree that the comparison must be fair, and we think the fair axis is cost rather than frame count. An 8B model is not expected to beat GPT-4.1 frame for frame, and at 16 frames it does not (Appendix B.2). The point of StreamGuard is that streaming lets it read the whole video at 2 FPS faster than any baseline reads 16 frames: 3.97 s serial / 2.14 s parallel vs. 4.05 s for its same-size base model InternVL3-8B and 4.94 s for GPT-4.1 (Table 7), while achieving the best F1. On the identical frames that StreamGuard ingests, classified one at a time by each baseline, StreamGuard still leads by 3.1 frame F1 (76.9 vs. 73.8, GPT-5). In the final version we will add open baselines at 32/64 frames and plot the full accuracy–latency frontier (G1).

W2 / Q2. Genuinely unseen policies (G2). We agree that Borderline/Erotic is close to the training data and have repositioned Table 3 as fine-grained policy refinement; the Dogs-vs-Cats results are now in Table 3. New evidence: Dogs-vs-Cats policy OOD (previously listed but not reported; StreamGuard 99.0 / 99.6 Dog / Cat accuracy, on par with Gemini-2.5-Flash, showing that safety training preserves non-safety policy following), and the new high-risk categories of Appendix B.1 (Table 9), evaluated by extending the policy prompt without retraining, where StreamGuard is best or tied on five of six categories. We agree that these categories are related to C5; policies fully disjoint from C1–C6 and a policy-flip test will be added in the final version.

W3 / Q3. VideoJail and SPTV (G3). Thank you for the pointers. Our TV2T transformations are related to VideoJail's visual-embedding strategy (we cite it in §4.3), and we agree that attacks built by other authors are a stronger test than our in-distribution TV2T/TV2V sets. VideoJail has no public implementation, so we evaluate SPTV, using its public release, and additionally MCV (ACL 2026), a multi-clip video jailbreak with public code and data. Neither attack nor its construction pipeline appears in our training data. We sample 400 MCV videos per setting and 500 SPTV videos, spanning the difficulty range of each set. StreamGuard labels as safe, i.e. misses, 23.4% of explicit and 34.4% of implicit MCV attacks, and 19.6% of SPTV attacks. The miss rate rises with the number of MCV clips, from 18.0% to 27.5% (explicit) and from 27.0% to 40.0% (implicit) as the attack grows from 1 to 4 clips, so longer multi-clip attacks remain a weakness. For context, the same videos jailbreak open MLLMs without a guardrail in 50–81% (MCV) and 30–44% (SPTV) of cases. These two rates are not directly comparable: one is a guardrail's miss rate, the other a target model's compliance rate. Together they show that the attacks are effective and that StreamGuard catches most of them. We will add other guardrails under the same protocol, and the false-positive rate on matched benign videos, in the final version. We have also added SPTV and MCV to the related work, and these results to a new appendix section.

Comments on the paper

2 comments

General Response (Part 1/2)

We have uploaded a revised PDF in which all changes are marked in blue.

We thank all reviewers for their careful reading and constructive feedback. Reviewers found the problem important and practical (egus, 3rMJ), the streaming architecture and parallel event-level inference useful (bhbp, 3rMJ), and Safe2Shot and AdvVideo-Bench to be valuable resources (bhbp). Below we address the three concerns raised by more than one reviewer; reviewer-specific points are answered in the individual responses.

G1. Frame budget and compute fairness (egus-W1/Q1, 3rMJ-W2/Q2). We do not claim that an 8B model is a stronger per-frame classifier than GPT-4.1 or GPT-5, and at an equal 16-frame budget it is not: Appendix B.2 shows 83.17 Acc for StreamGuard vs. 85.23 for GPT-4.1 (our description of this as "comparable" was inaccurate and has been corrected). Our claim is that the streaming design lets a small model cover the video densely at a cost below that of sparse baselines, so the fair comparison is at matched cost rather than matched frames. The existing results support this on three counts:

  • Matched cost. In Table 7 (SafeWatch-Bench), StreamGuard reads the whole video at 2 FPS in 3.97 s (serial) or 2.14 s (event-parallel). Every baseline reads only 16 frames and is slower: InternVL3-8B 4.05 s, SafeWatch 4.61 s, GPT-4.1 4.94 s, Claude-Opus-4.6 7.21 s, GPT-5 20.69 s. StreamGuard also has the best F1. It therefore lies on the accuracy–cost frontier, as stated in Appendix B.2.
  • Same model size. InternVL3-8B is StreamGuard's base model, so it has the same size and backbone. At nearly the same latency (4.05 s vs. 3.97 s), it sees 16 frames while StreamGuard sees the full 2 FPS stream. Dense coverage thus comes from the streaming design, with its event-level context resets and bounded context (Appendix B.3), not from the model being small.
  • Same frames. In our frame-level evaluation, every baseline classifies the identical frames that StreamGuard ingests, one at a time. StreamGuard reaches 76.9 frame F1 vs. 73.8 for the best baseline (GPT-5), which isolates the benefit of streaming temporal context at a matched frame set.

In the final version we will add open-weight baselines, including InternVL3-8B, at 32 and 64 frames and plot the full accuracy–latency frontier.

G2. Evidence for zero-shot policy generalization (egus-W2/Q2, 3rMJ-W6/Q6). We agree that Borderline/Erotic (Table 3) is close to the training distribution; we now present it as fine-grained policy refinement rather than as the main evidence for zero-shot generalization. Further evidence:

  • Dogs-vs-Cats (2,000 validation images, listed in §5.1 but missing from Table 3 of the submission). Under a policy that only asks whether a dog or a cat is present, StreamGuard reaches 99.0 / 99.6 accuracy on Dog / Cat, on par with Gemini-2.5-Flash (99.1 / 99.5) and above Qwen2.5-VL-7B (90.5 / 82.9). This shows that safety training does not erode the ability to follow a policy unrelated to C1–C6. It is a sanity check rather than evidence of generalization to new safety policies.
  • New high-risk categories (Appendix B.1, Table 9). Only the policy prompt is extended, without retraining, and StreamGuard is evaluated on five categories drawn from external datasets (Fire-Smoke, Gun, Shooting, Robbery, Drug) and a benign Religious category. It achieves the best or tied results on five of the six, e.g., Shooting F1 75.0 vs. 57.1 for GPT-4.1, and 100% accuracy on Religious, i.e. it does not over-block sensitive but benign content; GPT-4.1 is slightly better on Robbery. These categories are semantically related to C5, so they test transfer to new data sources more than to new policies.
  • We agree that policies fully disjoint from C1–C6, and a policy-flip test in which the verdict should follow a negated policy, would be the most direct evidence; we will add both in the final version.

General Response (Part 2/2)

G3. Robustness beyond the training attack distribution (egus-W3/Q3, 3rMJ-W4/W5/W6). As stated in §5.1, AdvVideo-Bench test attacks are in-distribution. To test generalization:

  • Unseen video jailbreaks. We evaluate on attacks built with the public MCV (ACL 2026) and SPTV (CVPR 2026) releases; neither attack nor its construction pipeline appears in our training data. VideoJail has no public implementation. StreamGuard misses (labels as safe) 23.4% / 34.4% of explicit / implicit MCV attacks and 19.6% of SPTV attacks, while the same videos jailbreak open MLLMs without a guardrail in 50–81% (MCV) and 30–44% (SPTV) of cases. Details are in the response to egus-W3 and in a new appendix section.
  • Adversarial data vs. policy alignment. Table 4 shows that the adversarial data is the main source of in-distribution robustness, and that policy alignment adds 2–5 points on top of it (response to 3rMJ-W6).
  • Generators and attack families. We now name the three TV2V generators (CogVideoX, Wan 2.1, Cosmos; 474 / 912 / 514 videos) in §4.2 and A.7. Leave-one-generator-out and leave-one-attack-family-out retraining will be added in the final version.

Summary of revisions (marked in blue in the revised PDF).

  • New results: unseen video jailbreaks (MCV, SPTV; new appendix section) and the Dogs-vs-Cats policy test (added to Table 3). The matched-cost analysis in G1 uses the existing Table 7 latencies and is now stated in Appendix B.2. Event-level localization, detection delay, denser baselines and leave-one-out retraining will be added in the final version.
  • Corrected Table 6 and Table 2 (also given in bhbp-Q4), with the evaluation protocol and full confusion matrices (see bhbp-Q4).
  • Wording: “frame-exact coverage without sampling loss” is replaced by “dense, uniform-rate coverage of every ingested frame”; the 16-frame result in B.2 is described accurately; TV2T/TV2V results are described as in-distribution.
  • Added details: SFT target construction, final-prompt length controls, the frame-level evaluation protocol, inference hardware and worker configuration, the TV2V generators, and a Limitations section.

From OpenReview, CC BY 4.0. Authors as signed there; shown unedited.

Related papers

Loading the map…

Discussion (0)

Sign in to comment.