2026-09-02

Other changes reviewed today:

• The same commit also added a mechanism that checks every 30 seconds whether the country lists of the Rust and Scala verdict stacks diverge.
• The same commit introduced a safety pipeline dedicated to highly popular videos, which uses motion-reveal frame detection as its entry condition.
• Of 30 new arXiv cs.IR submissions, only one, Snap's ads retrieval paper CAMIE, passed the close-reading criteria.

1The 16 countries where NSFW age gating is enforced are named in code for the first time — X

• The labeling path has four stages: Content Understanding → Labeling Rules → Storage → Visibility Filtering.
• Rules are split into three SafetyLevels (per-surface policy bundles). TimelineHomeRecommendations, for recommended posts, has 54 rules wired in (including the 28 of TimelineHome, for Following), and FilterAll has 1 verified — the wired_rule_order_matches_pre_migration_sequence test in visibility-filtering/rules/registry.rs.
• VF is fail-closed. Every path that returns without a verdict is treated as a drop.
• dark_traffic mirroring, the reference_compare harness, and a 90-case golden corpus automatically guard against regressions in the rewrite.

This commit adds two things to the stack:

• First, it states in code for the first time in which countries age gating is enforced. Previously, it was only known that the rule filtering viewers who had not stated their age decided on "no_stated_age + gated country", and the "gated country" list was not public.
• Second, it discloses for the first time a video-evasion countermeasure called motion-reveal (explained in C below). The prompt is structured so that the Grok LLM receives frames processed with this technique and uses them in its verdict.

A. The 16 NSFW gating countries are stated in code, and a mismatch with the Scala list becomes visible

This commit put the age-gating country list in code, together with mechanisms to change and monitor the list at runtime verified.

• The 16 NSFW gating countries went into a new file as defaults verified — visibility-filtering/params.rs.

  • The new file is visibility-filtering/params.rs (216 lines). A new struct NsfwGatingCountries holds the following 16 country codes as its default.

    pub fn default_nsfw_gating_countries() -> Vec<String> {
        [
            "ar", "au", "br", "ca", "de", "es", "fr", "gb", "id", "it", "kr", "mx", "nl", "ph", "pt",
            "th",
        ]
        .map(str::to_string)
        .to_vec()
    }
    

  • Spelled out: Argentina, Australia, Brazil, Canada, Germany, Spain, France, the United Kingdom, Indonesia, Italy, South Korea, Mexico, the Netherlands, the Philippines, Portugal, and Thailand.

• The list can be overridden at runtime with a feature switch and is re-read every 30 seconds verified — the spawn_refresh function in visibility-filtering/params.rs.
  • The feature switch is named rust_vf_nsfw_gating_countries, and the list is wrapped in an ArcSwap.
• With the Rust VF and Scala VF stacks running in parallel, a mismatch between the country lists the two stacks reference can now be observed verified — the check_drift function in the same file.
  • The refresh_and_check_drift function in the same file reads the sibling YAML file country_specific_nsfw_content_gating.yml on every refresh and checks whether the Rust-side result matches the Scala list.
  • The Scala VF stack references this YAML file.
  • If the two lists differ, it emits tracing::warn! and increments the nsfw_gating_countries_drift counter on xai_stats_receiver.
• If an invalid element is mixed into the array value, the whole default list is used instead of a partial one verified — the test section of the same file.
  • The regression test malformed_value_falls_back_whole_not_partial pins this contract. If a non-string element (for example the number 7) is mixed into the array value, the full fallback is used rather than a partial list.
  • For example, if the feature switch is misconfigured as ["xx", 7], it does not end up in a half-way state such as "gate only xx". Everything reverts to the 16 default countries.
  • This rules out the scenario in which partial loading confuses the understanding of the policy.
• Of the three NSFW age-gating rules, the country list is injected into only one, the rule for viewers with no stated age verified — visibility-filtering/rules/nsfw_age_gating.rs:68-88.
  • For media candidates carrying an NSFW/GORE label, the three rules run in parallel.
  • If the viewer is logged out, the media is dropped unconditionally regardless of country (SensitiveViewerLoggedOutDropRule).
  • If the viewer is confirmed to be under 18, the media is dropped regardless of country (SensitiveViewerUnderageDropRule).
  • If the viewer has not stated an age and is in the 16-country list above, the media is dropped (SensitiveViewerNoStatedAgeDropRule).
• The third rule references this country list. That is, age gating is enforced only in the 16 countries for viewers with no stated age.
  • In other countries (for example the US, Japan, and Russia), this rule does not apply even when the age is unstated.

"base: !context.viewer().is_author() && tweet.has_media() && (tweet.has_safety_label(SafetyLabelType::NSFW_HIGH_PRECISION) || tweet.has_safety_label(SafetyLabelType::NSFW_HIGH_RECALL) || (tweet.is_nsfw_flagged() && !tweet.is_retweet())) ... if context.viewer().has_no_stated_age() && context.viewer().country().is_some_and(|c| self.gating_countries.contains(c)) && sensitive_base_condition(context) → Drop(FilteredReason::ContainNsfwMedia)" — visibility-filtering/rules/nsfw_age_gating.rs

B. A new safety pipeline inspects only highly popular videos

The new special-video pipeline is the most expensive layer among the safety-verdict pipelines of grox (the Grok-based nearline classifier sub-repo). grox was already running several safety-verdict pipelines in the Content-understanding stage. The new pipeline admits only videos with a high favorite count (deluxe tier, that is, videos whose favorite count is at or above a threshold), runs them through a multi-step task DAG, and then calls a Grok 4.5 judge. The core of this commit is that such a setup has been released in code for the first time.

• A new file defines a 9-stage DAG in which nine tasks are chained in a single line verified — grox/flows/ptos/plan_safety_ptos_special_video.py.

  • The new file is grox/flows/ptos/plan_safety_ptos_special_video.py (55 lines), and the pipeline name is PlanSafetyPtosSpecialVideo.

  • The dependency graph is as follows:

    special_video_filter
        → annotation_rate_limit
            → media_hydration
                → special_video_screen
                    → category_detection
                        → policy_detection
                            → safemodel_sex_nudity
                                → adult_content_cross_validation (depends on both policy·safemodel results)
                                    → result_sink
    

• The first task, special_video_filter, admits only posts that satisfy all three conditions verified — grox/flows/ptos/task_safety_ptos_special_video_filter.py.

  1. The post must have user information (it must not be no_user).
  2. The media must contain at least one Video. Media of a quoted post is counted too.
  3. The fav count must be at or above grox_config.media_hydration.deluxe_fav_count_threshold.

• That is, this pipeline is entered only by high-favorite videos that are confirmed viral.

  • The exact value is not public, but because the name is deluxe_fav_count_threshold, the threshold is presumed to be quite high inferred.
  • This gating itself is cost control. Screening, verdicts, and LLM cross-validation are all much more expensive per candidate, so the pipeline is not extended to low-favorite videos.

• The core of the new pipeline is the special_video_screen task. If a video has motion-reveal frames, it passes that video on to special screening verified — grox/flows/ptos/task_special_video_screen.py.

  • After media hydration, it checks the motion_reveal_frames field of each video and, if the field is not empty, admits the video to special screening.

    @classmethod
    def _technique_signals(cls, convo_video: ConvoVideo) -> dict[str, bool]:
        return {
            "motion_reveal": bool(convo_video.motion_reveal_frames),
        }
    

  • The value returned by _eligible_with_post is the gate to the next task. Only videos caught by screening become True.

  • The technique currently detected is only motion_reveal, but the dict is open-ended. If other evasion techniques are added later, this dict will be extended.

C. Motion-reveal subtracts the static layer and amplifies the moving layer to reveal what is under an overlay

A motion-reveal frame is a frame in which the static layer is subtracted from the original video and the faint moving layer is amplified. This processing reveals the actual content hidden behind a static overlay on the video (for example a caption image, a transparent mask, or a watermark). One adult-content evasion technique is to cover an adult video with a static image overlay, and motion-reveal removes that overlay computationally.

• A constant defined in grox/core/lm/convo.py reveals the intent of this technique verified — grox/core/lm/convo.py.

"Motion-reveal stills for this video follow (static layer subtracted, faint moving layers amplified); they distort colors and motion, and can make opaque clothing look like bare skin. People or acts absent from the frames above but visible here are the video's actual overlay-hidden content; judge anyone already visible above solely from the original frames." — grox/core/lm/convo.py MOTION_REVEAL_DESCRIPTION

The constant's wording states two important points clearly:

• First, motion-reveal frames can distort colors and motion. The prompt itself contains a warning that motion-reveal post-processing can create artifacts that make "opaque clothing look like bare skin".
  • That is, this signal may have high recall but low precision. So it is not used for unconditional hard verdicts; it is used only as an entry signal to a pipeline that goes through downstream category verdicts and cross-validation.
• Second, the verdict treats the original frames and the motion-reveal frames separately. The prompt contains a judging rubric: "judge a person already visible in the original frames solely from the original; if something newly appears only in the motion-reveal frames, that is the truly hidden content".
  • In other words, the comparison with the original frames offsets the false impression motion-reveal creates (clothing appearing stripped on a person who is already present in the original).

Image-processing functions that produce motion-reveal frames were also added verified — grox/libs/video_tools/image.py. The file is grox/libs/video_tools/image.py (+125), and the functions include CLAHE, adaptive brightness, saturation boost, and sharpen. That is, X put preprocessing that actively transforms video frames to reveal evaded content into its production safety pipeline.

D. Videos that pass screening go through the existing verdict stages up to the Grok 4.5 judge

After motion-reveal screening, the existing pipeline continues unchanged.

• After screening come the category verdict and the policy verdict, and after the safemodel verdict, cross-validation runs verified — TASK_DEPENDENCIES in plan_safety_ptos_special_video.py.
  • The category verdict is TaskSafetyPtosCategoryDetection, and the policy verdict is TaskSafetyPtosPolicyDetection.
  • The two tasks that run in sequence are TaskSafetyPtosSafemodelSexNudity and TaskSafetyPtosAdultContentCrossValidation. The latter depends on both the policy verdict and the safemodel verdict results.
  • Then TaskWriteSafetyPostAnnotationsResultSink records the result.
• The last two tasks were first released in the 2026-08-17 commit (Gen4+2). safemodel is an in-house vision model, and PtOS is a policy tag. If the two verdicts differ, Grok 4.5 re-judges as the judge.
  • To be precise, the judge is the EAPI_GROK_4_5_X_ALGO endpoint.
  • The Grok judge works only in the demotion direction: "if hard adult content, keep the original verdict; if soft, demote". This is already reflected in the existing canon.
• What this pipeline newly does is narrow the candidates that reach this point by motion-reveal screening. That is, it picks only candidates caught by a specific evasion technique and sends them through this expensive verdict stack.
  • This setup aims to achieve cost control and higher recall at the same time inferred.
• If the Grok 4.5 judge call fails on the special-video path, the verdict is demoted to Soft verified — grox/flows/ptos/task_safety_ptos_adult_content_cross_validation.py lines 102–117.
  • The place checked is this task's _cross_validate flow.
  • If the Grok judge call fails with an exception, the special-video path with task_type == SAFETY_PTOS_SPECIAL_VIDEO does not keep the original verdict but forcibly demotes it to Soft ("Grok 4.5 Cross Validation failed").
  • On other paths, keeping the original verdict was the default; only the special-video path has a different fail-close policy.
  • That is, X adjusted this pipeline's output in a more cautious direction. If the judge fails, a safe verdict takes precedence over a harmless one.

• Added a new Gen4+12 (2026-09-01, 6384ca7) subsection to the safety / visibility-filtering / labeling pipeline section. It covers the list of 16 NSFW country-gating entries, drift monitoring between Rust and Scala, the PlanSafetyPtosSpecialVideo DAG, and the motion-reveal evasion countermeasure.
• Added a Gen4+12 row to the public-source Gen4 table.
• Added a sentence summarizing this commit to the one-line summary.
• Changed last updated to 2026-09-02.

• First, X stated in code for the first time in which countries it enforces age gating.
  • This list already existed in the Scala VF (country_specific_nsfw_content_gating.yml) too. Now that it also enters the Rust VF as a default and a mismatch between the two lists can be observed through a metric, X appears to be moving to complete the migration to Rust safely.
  • The selection criteria for the 16 countries are not stated. The list includes six EU member states (Germany, Spain, France, Italy, the Netherlands, Portugal), Anglo countries such as the UK, Canada, and Australia, the Latin American countries Brazil, Argentina, and Mexico, and the Asian countries South Korea, Indonesia, Thailand, and the Philippines.
  • The US is not on the list. Within the US, this rule does not apply even to viewers with no stated age.
  • Logged-out viewers and viewers confirmed to be minors are handled by separate rules that drop regardless of country (section A above).
• Second, the safety stack gained a layer that actively counters evasion.
  • Until now, X's safety pipeline was a passive stack: "the model attaches a label → the rules decide".
  • Now a layer has been added in front of it: "detect the evasion technique → actively build frames with the evasion removed → judge again with those frames".
  • It gives the Grok LLM both frame sets, original and motion-reveal, and also puts the caveat that "motion-reveal creates distortion" in the prompt. That is, it uses LLM verdicts as an evasion-countering tool while managing the tool's limits through the prompt.
• Third, the evasion countermeasure is limited to high-favorite videos.
  • Only videos with a fav count at or above deluxe_fav_count_threshold enter this pipeline; those below it go through only the default pipeline (up to safemodel and PtOS).
  • X built this setup on a dual logic. It manages cost by applying expensive evasion countermeasures only to content whose spread is confirmed, and because such content also has a large incentive for evasion owing to its reach, it strengthens evasion detection.
  • An open weakness of this architecture is that evasion cannot be detected while a new video still has a low favorite count. This weakness would need to be covered by re-running the verdict after spread begins and processing retroactively. However, it has not been confirmed whether a retroactive path is public.
• Fourth, there is room to add new evasion techniques.
  • The structure of the _technique_signals dict is shaped in anticipation of new techniques. Which evasion technique is added after motion-reveal is the thing to watch.
  • Candidates include text evasion that hides hate speech behind a caption overlay, temporal evasion that keeps only the first frame harmless with a splash frame, and chroma key insertion evasion inferred.
• Compared with Meta and Netflix in the canon, this X setup is recorded as the first case of a large open platform releasing an active evasion-countering layer in code.
  • Meta released its brand safety stack only for the ads domain and did not release evasion countermeasures for its organic feed.
  • Netflix's catalog is curated, so the category of UGC evasion countermeasures does not exist at all.

2Of the new cs.IR papers, only Snap's CAMIE passed the close-reading criteria — arXiv

• Platform-company authors and a production A/B claim.
• A new mechanism for feeds, ranking, or retrieval.
• Large-scale results.

According to the canon guidelines in CLAUDE.md, most papers being rejected is normal, and 0–2 pass per day. In this lookup, 1 of the latest 30 passed.

• Snap published the CAMIE paper on I2I (item-to-item) retrieval for ads surfaces and stated a production deployment in the abstract verified — arXiv 2608.30255, submitted 2026-08-31.
  • The target surface is Snap Dynamic Product Ads (DPA), an ads surface.
  • The problem it addresses is that separately trained visual, text, and multimodal encoders fragment the embedding space and fail to reflect co-engagement signals (the relation of the same user viewing two products together).
  • There are 12 authors, and the HTML body lists all of them as affiliated with Snap Inc. (Xiaodong Liu, Siman Wang, Congfei Zhang, Hsiang-wei Chao, Xiao Bai, and others) verified — arXiv 2608.30255.
  • Added to radar.md as a watching entry.

• The papers that did not pass were mostly of three types.
  • Methodology research such as benchmarks, vector quantization, and RAG evaluation. There is no production claim from a platform company.
  • Sources with restricted domains such as POI, medical, and scientific literature. These are explicitly excluded in the acceptance criteria.
  • e-commerce SID (semantic ID) experiments whose author affiliations cannot be confirmed. Preference Shapes Relevance, ICEGR, and others belong here; they are a thread similar to PailitaoGR but have no production claim.
• Only two interesting adjacent sources are left as pointers.
  • SetMIR in arXiv 2608.30251 is a paper on multi-interest retrieval as set prediction. The authors are from the same Snap group (Xiaodong Liu, Siman Wang, Congfei Zhang, Hsiang-wei Chao, Xiao Bai). The abstract alone does not state a Snap production claim explicitly, so it is not folded into the canon.
  • CHASE in arXiv 2608.30466 deals with the effect of GEO (Generative Engine Optimization) homogenizing content in LLM-based retrieval. It is an issue adjacent to recommendation ranking, but the authors are not from a platform company, so it is not folded into the radar either.

Radar

• Snap CAMIE (arXiv 2608.30255) deployed co-engagement-aware multimodal item embeddings in I2I ads retrieval for Snap Dynamic Product Ads. The abstract states the production deployment. Added to new this month in radar.md.

What to check next