How retrieval, transcript IDs and deterministic assembly reduced long-video generation context from about 4,600 to 860 tokens in a small locked holdout—and where the system still failed.

Selecting grounded video spans with an 8B local model using 81% fewer input tokens

The obvious way to let an LLM edit a long video is to transcribe it, send the full transcript to a large hosted model, and ask for timestamps. We tried variations of that idea. It is expensive, difficult to audit, and surprisingly fragile at the point that matters most: turning generated prose into cuts that actually exist in the source.

We built a different path for BonFrame. The full transcript remains a local, indexed project asset. Retrieval produces a short directory of candidate blocks. A local model may select block IDs, but it cannot invent timestamps or rewrite a sentence and pretend that the sentence appeared in the recording. Deterministic assembly then applies duration and exclusion rules.

On a locked holdout of eight videos, repeated three times per case, an 8B local model passed our combined mechanical and model-judged gate 17/24 times. A DeepSeek full-transcript baseline passed 15/24 times. Mean generation input fell from about 4,600 tokens to 860, a reduction of 81.3%.

This is not evidence that an 8B model generally beats cloud models. The sample is small, the comparison uses one cloud baseline, and the blind review was performed by another model rather than humans. One Docker video failed every path. The useful result is narrower: once a video editing task is grounded in retrieved transcript spans, model size and full-context access stop being the only way to obtain a usable cut.

The task we stopped asking models to do

A prompt such as “turn this lecture into a concise explanation of Git” hides at least four jobs:

interpret the editorial intent;
find claims, examples and boundaries across the recording;
map those ideas back to exact source sentences;
assemble a coherent duration while excluding intros, promotions and incomplete fragments.

A full-context model can perform all four in one generation. That does not mean it should. It may return plausible timestamps that do not align with transcript boundaries. It may summarize an example instead of selecting the spoken example. It may retain an energetic introduction because the words are topically relevant even though the segment is editorially useless.

Small local models perform worse when given the same unconstrained job. Long prefill is slow, context may not fit, and a smaller generator is no more entitled to invent timecodes than a large one.

Our change was to remove the parts that should not be generative.

source media
  → local transcription with stable sentence IDs
  → local embeddings and reusable index
  → prompt compiler: intent, inclusions, exclusions, duration
  → retrieval of grounded candidate spans
  → ordered block directory with real source IDs
  → constrained 3B / 8B block selection
  → deterministic assembly and quality gates
  → inactive proposal for review

The generator may choose from the directory. It cannot introduce a block that retrieval did not provide. Start and end times come from transcript IDs, not generated numbers. If the requested subject is absent, the correct result is a clarification or a grounded failure—not a fluent approximation from model memory.

Index once, query many times

Transcription is the factual layer. Each sentence and word remains tied to source time. Embeddings add a reusable retrieval layer; they are not a lossy replacement for the transcript.

That distinction matters for both privacy and cost. A two-hour recording may contain private conversations, unreleased claims, names, voices and mistakes that will never appear in the final minute. Re-uploading the full transcript for every edit exposes and pays for all of it repeatedly. A local index allows each edit to retrieve only the evidence required for the current decision.

Retrieval is not “giving the model a permanent memory of the video.” It is closer to building an addressable table of contents. The source transcript remains the authority. The index answers where to look; stable IDs answer what can actually be cut.

Our first grounded system still lost

The first holdout result is important because it prevents a convenient story about retrieval automatically solving the problem.

We froze eight transcripts that had not been used to tune the assembly rules. A rule-based local path passed the combined gate on 2/8 cases. A DeepSeek path that read the full transcript passed 5/8. Mechanical duration gates could be made comparable, but independent review did not establish non-inferiority for the retrieval path.

The failure was not “the local model is too small,” because this version had no local generative selector in the main path. Retrieval found relevant material, but rules assembled too much of it or chose the wrong local cluster. Related sentences became a collage rather than an edit.

That failure changed the division of labor:

retrieval continued to find grounded evidence;
candidate sentences were grouped into an ordered block directory;
a local model selected existing block_id values;
frozen assembly converted selected blocks into a timeline;
mechanical gates still enforced duration and source validity.

The model was no longer asked to direct an entire long video. It was asked to make a bounded editorial choice among a small number of already relevant, already timed blocks.

The locked comparison

The product-protocol run reused the same eight unseen cases without changing assembly gates on those cases. Each case was run three times, producing 24 trials per path. Labels were swapped by case and repeat. Mechanical checks covered duration and structural requirements; a separate GPT-5.1 judge evaluated grounding, coverage, exclusions and coherence.

Path	Mechanical gate	Combined pass	Mean generation input
BonFrame `/cut` + local Ministral 8B	24/24	17/24 (70.8%)	860 tokens
DeepSeek full transcript	24/24	15/24 (62.5%)	4,600 tokens
BonFrame `/cut` + local Ministral 3B	24/24	14/24 (58.3%)	860 tokens

The 8B path was 8.3 percentage points above this baseline. The 3B path was 4.2 points below it, inside the predeclared -5 point non-inferiority margin. Both local paths reduced mean generation input by 81.3%.

There was also a same-evidence cloud path in which DeepSeek selected from the short block directory. It scored 11/24 in the 8B protocol run and 9/24 in the 3B run. We do not treat that as proof that local models are intrinsically better selectors. It indicates that once evidence is compressed into a constrained directory, the remaining decision is not automatically improved by using a hosted model.

Full context still helped on individual cases. In the 3B run, the full-transcript path was stable on photosynthesis while the short-directory paths often stopped before the complete mechanism. That is a retrieval or candidate-boundary failure, not a reason to erase the comparison.

What failed

The Docker case is the clearest counterexample. In the 8B protocol, all three paths scored 0/3. In the 3B protocol, the local path scored 0/3 and the full-transcript path only 1/3. Promotional introductions and demo-heavy sections looked relevant enough to survive selection, while coverage remained incomplete.

Other failures included:

cutting before a mechanism or example was complete;
retaining an intro because it repeated the target topic;
choosing a coherent local cluster that omitted a required boundary;
block boundaries that ended in the middle of a useful explanation.

A larger generator does not directly repair all of these. Some require better retrieval diversity, discourse-aware boundaries or stronger exclusion gates. The architecture helps by making each failure inspectable: we can see the retrieved evidence, selected IDs, rejected candidates and final assembly. A full-context answer that only returns prose and approximate timestamps is harder to debug.

What the result supports

The experiment supports three engineering claims.

First, exact edit coordinates should come from source-linked data, not generated timecodes. This removes an entire class of hallucination regardless of model size.

Second, reusable retrieval can reduce the context required for repeated edits. The saving applies even when the media is not sensitive enough to require an offline workflow.

Third, a small model can be useful when the system gives it a bounded decision. “Select two to five IDs from this grounded directory” is a different problem from “read an 81-minute transcript and become the editor.”

It does not support these claims:

local 8B models generally outperform ChatGPT, Claude or all cloud LLMs;
81.3% is a universal token reduction for every video;
model judging is equivalent to human editorial review;
passing a structural gate guarantees that a video feels excellent;
eight holdout cases are enough to establish broad production quality.

The next evaluation needs a larger locked set, human blind review, more languages and stronger adversarial intros. It should preserve the failure history rather than retune on this holdout and report the same set again.

From one cut to an unattended batch

Grounding also changes what an agent can safely automate. Codex or Claude does not need raw media in its conversation to coordinate a BonFrame machine. It can create a local batch job, inspect project-level status, receive short evidence and proposal IDs, and open a controlled review page.

The machine can run discovery, indexing, prompt generation, Hook candidates, rhythm analysis and bounded variants overnight. It stops at review_ready. Approval, applying a proposal to the active timeline and export remain explicit operations.

That boundary is deliberate. The productivity gain is not “the agent publishes a hundred videos without supervision.” It is “the next morning begins with grounded, replayable candidates and a short exception list instead of an empty timeline.”

Reproducibility and current limits

The public benchmark note includes the protocol, the earlier negative holdout, the 8B and 3B aggregate results, failure categories and the exact scope of permitted claims. Customer media, private source code and credentials are excluded.

The key limitations are unchanged:

eight holdout videos;
three repetitions per case in the product protocol;
one locked cloud generation baseline;
GPT-5.1-assisted blind review rather than human blind review;
one persistent Docker failure;
no claim of platform engagement or “viral” prediction.

We are publishing the failure before the improved result because it explains what actually mattered: not fitting a larger model into the same architecture, but changing which parts of video editing were allowed to be generative.

BonFrame is the product built on this local DeerClip engine. Subscribe to BonFrame Engineering for the benchmark pack and the next report on Hook candidates, rhythm gates and unattended batch review. No raw media is required to join the newsletter or inspect the methodology.