DEV Community: Abdullah Baig

The Remote Control Wasn’t Fast Enough

Abdullah Baig — Wed, 09 Sep 2026 17:00:00 +0000

You sit down for a family movie. The popcorn is ready. Two characters start looking at each other with suspiciously good lighting.

Suddenly, you’re reaching for the remote like you’re defusing a bomb.

Naturally, the engineering response is to build an application that removes kissing, sex, and intimate scenes. Your children can continue believing babies arrive through a logistics provider with excellent last-mile delivery.

The interesting part is that we can search a video using an ordinary description, like “two people kissing,” without training a dedicated kissing detector.

That’s called open-vocabulary search. Your search terms don’t have to come from a fixed menu of labels.

1. Give the movie something searchable

We’ll use jinaai/jina-embeddings-v5-omni-nano, the multimodal member of Jina’s v5 family. It represents text and video in a shared vector space, letting us compare a written description with a clip. Use the Omni model here; the text-only version cannot watch your movie. Jina’s model card

The workflow is small:

Divide the timeline into short windows.
Embed sampled frames from each window.
Compare them with descriptions of the scenes we want to find.
Review matching timestamps.
Export a copy with selected intervals removed.

These are time windows, not detected cinematic scenes. We’ll start with two seconds per window and four sampled frames per second. Brief events can still slip between samples, so this is a prototype, not a parental guarantee.

2. Install the pieces

Start with a short local MP4 before processing an entire film.

pip install "torch>=2.5" "transformers>=5,<6" \
  sentence-transformers pillow numpy \
  "moviepy>=2,<3" imageio-ffmpeg

A CUDA GPU is useful for testing. If you don’t have one, you can use a Runpod GPU Pod with its PyTorch template. This post hasn’t been sponsored by them. Apparently, protecting fictional children from fictional romance does not qualify for a marketing budget.

The model requires trust_remote_code=True, which runs code from its repository. Review that code and pin a reviewed revision when turning this into a maintained application.

3. Find the suspicious affection

We’ll search with several descriptions. A kissing query alone may miss a sex scene without kissing, while a broad query about intimacy might enthusiastically flag an innocent hug.

Save this as find_scenes.py, alongside movie.mp4:

import csv
import numpy as np
from moviepy import VideoFileClip
from sentence_transformers import SentenceTransformer

model = SentenceTransformer(
    "jinaai/jina-embeddings-v5-omni-nano",
    trust_remote_code=True,
    device="cuda",
    model_kwargs={
        "default_task": "retrieval",
        "modality": "vision",
    },
)

descriptions = [
    "Two people kissing on the lips",
    "A sex scene between adults",
    "Adults undressing each other romantically",
    "Adults touching and embracing intimately in bed",
]

queries = model.encode_query(
    descriptions,
    normalize_embeddings=True,
    convert_to_numpy=True,
)

rows = []
vectors = []

with VideoFileClip("movie.mp4", audio=False) as video:
    preview = video.resized(width=384)

    for start in np.arange(0, video.duration, 2.0):
        end = min(start + 2.0, video.duration)
        frames = np.stack([
            preview.get_frame(float(t))
            for t in np.arange(start, end, 0.25)
        ]).astype(np.uint8)

        vector = model.encode_document(
            [frames],
            normalize_embeddings=True,
            convert_to_numpy=True,
        )[0]

        scores = queries @ vector
        best = int(np.argmax(scores))

        vectors.append(vector)
        rows.append({
            "start": float(start),
            "end": float(end),
            "score": float(scores[best]),
            "match": descriptions[best],
            "remove": "no",
        })

# Preserve chronological embeddings for future searches.
np.save("embeddings.npy", np.stack(vectors))

with open("windows.csv", "w", newline="") as f:
    writer = csv.DictWriter(f, fieldnames=rows[0].keys())
    writer.writeheader()
    writer.writerows(rows)

with open("review.csv", "w", newline="") as f:
    writer = csv.DictWriter(f, fieldnames=rows[0].keys())
    writer.writeheader()
    writer.writerows(
        sorted(rows, key=lambda row: row["score"], reverse=True)
    )

Jina documents both in-memory video frames and separate encode_query() / encode_document() methods for retrieval. Normalizing the vectors makes their dot product a cosine similarity score. Input formats and retrieval usage

Run:

python find_scenes.py

Open review.csv. Each row includes its strongest matching description. Watch the highest-ranked intervals, change remove to yes for the ones you want cut, and adjust their start and end times as needed. Timestamps are in seconds.

A similarity score is not a probability that a scene contains kissing or sex. Close conversation might rank highly. An actual intimate scene might rank lower. There’s no universal threshold where responsible parenting begins.

The match column is also just the closest search description, not a confirmed label. Every window gets a match, including the establishing shot of a completely innocent mountain.

You can reuse the saved embeddings for different descriptions without processing the movie again.

4. Perform the extremely modest director’s cut

Save this as cut_scenes.py:

import csv
import math
from moviepy import VideoFileClip, concatenate_videoclips

with open("review.csv", newline="") as f:
    cuts = sorted(
        (float(r["start"]), float(r["end"]))
        for r in csv.DictReader(f)
        if r["remove"].strip().lower() == "yes"
    )

with VideoFileClip("movie.mp4") as video:
    merged = []

    for start, end in cuts:
        if not (
            math.isfinite(start)
            and math.isfinite(end)
            and 0 <= start < end <= video.duration
        ):
            raise ValueError(f"Invalid interval: {start}, {end}")

        if merged and start <= merged[-1][1]:
            merged[-1][1] = max(merged[-1][1], end)
        else:
            merged.append([start, end])

    keep = []
    cursor = 0.0

    for start, end in merged:
        if start > cursor:
            keep.append(video.subclipped(cursor, start))
        cursor = end

    if cursor < video.duration:
        keep.append(video.subclipped(cursor, video.duration))

    if not keep:
        raise ValueError("Every frame was selected. Bold edit.")

    with concatenate_videoclips(keep) as result:
        result.write_videofile(
            "movie_edited.mp4",
            codec="libx264",
            audio_codec="aac",
        )

Then:

python cut_scenes.py

This merges overlapping cuts and joins the remaining video with its corresponding audio. MoviePy re-encodes the result; the source file stays intact. This minimal export uses the loaded video and audio, and does not preserve every subtitle or alternate audio track. MoviePy’s editing documentation

The model calls follow Jina’s documented interface; detection accuracy has not been tested here on a movie.

Intimacy is annoyingly contextual

A kiss, a hug, and a sex scene are different things. Even “intimate” can describe anything from a quiet conversation to a scene that sends you searching for the remote under three cushions.

Use descriptions that match what you actually want removed. Review a few seconds before and after each result, then extend the cut to cover the full moment. Otherwise, you might remove the kiss while leaving the entire buildup and a rather confusing aftermath.

There’s another limitation: Jina’s video input reads frames, not the soundtrack automatically. Suggestive dialogue or off-screen sexual activity may require separate audio analysis or timestamped transcription. The example here searches visible content. Jina’s video-input documentation

For better coverage, try overlapping windows and denser frame sampling, then measure what the system misses on clips you have reviewed yourself. More sampling costs more processing. It also remains cheaper than discovering your filter’s limitations during family movie night.

When the family library becomes infrastructure

For one movie, a NumPy array is enough. For many videos, I’d store vectors with video_id, start time, end time, and model version in Qdrant or Elasticsearch. That gives us indexed similarity search and metadata filtering across the collection.

Before making this a commercial application, note that the model’s published license is CC BY-NC 4.0; Jina directs commercial users to contact them. Model license

The useful capability is simple: describe a moment, retrieve likely matches, and turn timestamps into edits. Your search vocabulary can change without training another detector. Deciding what belongs in the final cut is still your job.

Would you like me to cover the version that handles many videos with Qdrant or Elasticsearch? Say so in the comments.

OpenAI Says It Cracked Navier-Stokes. It Took Roughly 10,000 AI Agents.

Abdullah Baig — Wed, 09 Sep 2026 14:16:55 +0000

OpenAI has announced a proposed solution to the Navier-Stokes existence and smoothness problem, one of the seven Millennium Prize Problems.

As a mechanical engineer, that is a strange sentence to read. These equations are fundamental to how we understand fluid motion. Now an AI lab says its system has resolved a question about them that has remained open for roughly 90 years.

The announcement was published on September 8. OpenAI released a mathematical writeup and a formalization in Lean, although the claim still needs independent scrutiny. Read the announcement

What does “solving Navier-Stokes” mean?

The equations describe how fluids move. Engineers already use them to study airflow, water flow, and other physical systems.

The Millennium Problem asks a more fundamental question: under the specified conditions, do smooth three-dimensional fluid flows remain smooth, or can they break down?

OpenAI claims an initially smooth fluid at rest can develop a singularity under a smooth external force. In its construction, velocity grows without bound in finite time, while the fluid’s energy remains finite. The claim concerns the mathematical model, not real water suddenly moving infinitely fast. OpenAI’s description of the result

The external force does not automatically disqualify the result. Clay’s official formulation explicitly includes breakdown cases with smooth forcing. OpenAI says its proof establishes alternatives C and D. Clay’s official problem statement

How the agents approached it

OpenAI used an unreleased internal model that it describes as significantly more capable than GPT-6 Astra.

The effort initially covered several mathematical problems. After agents produced an earlier result on the unforced Euler equations, researchers concentrated resources on Navier-Stokes and shared intermediate findings between groups.

Euler equations remove viscosity. “Unforced” means no external force is applied. Those are separate distinctions.

Part of the effort	OpenAI’s reported figure
Concurrent agents in the successful group	Roughly 10,000
Time from the first agents launching to resolution	About 88 hours
Additional Lean formalization and verification using GPT-6 Astra	17 hours
Output tokens used for the Navier-Stokes effort	Approximately 130 billion

These figures describe a coordinated research effort with human steering and substantial compute. How OpenAI says it found the proof

What the Lean verification establishes

Lean is a programming language and theorem prover. Its checking system can verify that a formal proof follows from the definitions and assumptions it uses.

That matters because the output includes something others can check beyond a written explanation. OpenAI has published the formalization on GitHub.

However, a checked proof still needs to express the intended mathematical problem correctly. Its assumptions and dependencies also require examination. Formal verification and independent mathematical review address different parts of establishing a result. Lean’s verification guide

What remains unsettled?

The announcement should still be described as a claimed resolution, rather than an independently accepted result.

There are also questions about credit and provenance. OpenAI discusses concurrent work by Levent Alpöge and Tristan Buckmaster, acknowledges their priority on forced Euler, and says it cannot rule out a contribution to model improvement from de-identified product usage. The correctness of a proof would not, by itself, settle those questions. OpenAI’s account

OpenAI also says it does not intend to claim the Millennium Prize.

Why this is worth watching

If the result holds, its significance extends beyond fluid mechanics. It would be evidence that a coordinated AI system can contribute to resolving a major open problem and produce a formal artifact for others to examine.

For developers, the interesting combination is sustained exploration, shared intermediate results, and a separate checking process. How much of that can become practical at smaller budgets remains an open question.

For now, there is a substantial mathematical claim on the table, a published proof to investigate, and a research process worth understanding. That is already plenty to take in.

The ideas we never got around to testing

Abdullah Baig — Wed, 09 Sep 2026 13:09:56 +0000

Every engineering team has ideas that quietly become assumptions because nobody has time to test them. A different retrieval strategy might improve accuracy. A smaller model might be sufficient. An architectural decision made six months ago might no longer make sense. Eventually, “we haven’t checked” hardens into “this is how it works.”

AI’s growing ability to carry out research could make those assumptions cheaper to question.

On September 6, OpenAI reported reaching its internal milestone of an automated research intern: a system capable of performing well-defined research tasks under human direction, including work that would take a skilled researcher several days. This is the company’s own assessment, rather than independent proof of general research ability. But it identifies a consequential capability: delegating an investigation whose answer you do not already know. OpenAI’s research report

The practical opening is a smaller commitment between having a hypothesis and obtaining evidence.

Consider a founder wondering whether an expensive model is necessary for their product. A useful investigation would assemble representative examples, compare alternatives, inspect failures, and establish where the cheaper option breaks down. Each step is familiar engineering work. Together, they can be substantial enough to keep the question on the backlog.

An agent that can carry much of that investigation makes a previously uneconomical question worth asking. The novelty is in how much exploratory work can now be delegated before the human has resolved the uncertainty.

There are limits. OpenAI reports that more than half of successful tasks estimated at four to eight human hours involved at least one intervention. It also cautions that increased experimentation coincided with increased compute, so the results do not isolate the contribution of agents. Methods and findings

Even within those limits, the implication for builders is substantial. A small team may be able to examine more alternatives before committing to one. Engineers could revisit decisions whose original justification was simply that there was no time to investigate further.

But cheaper experimentation places more responsibility on the question itself. An agent can compare models against a benchmark that misses the customer’s actual problem. It can execute a rigorous experiment around an assumption nobody thought to challenge. More evidence only helps when it bears on the decision being made.

That makes this development slightly uncomfortable. Limited capacity has always supplied a reasonable explanation for leaving things unexamined. As that constraint loosens, we may discover how often we were protecting a familiar answer.

The first useful application of an automated researcher may be an experiment we have been postponing because we suspect it could change our minds.