From a 16-Minute Lecture to One Short in 15 Minutes: Testing TwelveLabs Jockey MCP

I pasted a YouTube URL and asked for one promising short. About 15 minutes later, a 16-minute-and-4-second introductory Git and GitHub lecture had become a vertical MP4. Indexing took roughly four minutes. My direct involvement—choosing a candidate and checking the final frames—took about two.

Using an assumed set of calls and TwelveLabs’ public API rates, the workflow comes to about $1.64. That is not a Jockey invoice. Jockey has separate product plans, and an agent may make a different number of internal calls, so the account dashboard remains the source of truth.

Can I finish a short without watching the entire source video?

In this trial, yes. But segment discovery and subtitle timing required very different levels of precision.

Turning review into discovery

I had previously used Jockey to review a lecture. This time I reversed the direction. Review asks what is wrong with something already made. Short-form production asks what is worth extracting from it. Both share the same bottleneck: someone has to watch the video.

The pipeline

I connected Jockey MCP to a Claude Cowork session and used ffmpeg in the same environment.

flowchart LR
    A[YouTube URL] --> B[Jockey indexing]
    B --> C[JSON schema query]
    C --> D[Five candidates]
    D --> E[Human selection]
    E --> F[Transcript correction]
    F --> G[ffmpeg vertical edit]
    G --> H[Frame verification]
    H --> I[Final MP4]

The tools mattered less than the contract between stages. Once Jockey returned numeric start_sec and end_sec values, ffmpeg could consume them directly.

Step 1: Indexing from a YouTube URL

I passed the link to jockey_add_media. In this run, the 964-second, roughly 35 MB lecture moved from queued to ready in about four minutes. The completed index also exposed an HLS stream URL, allowing ffmpeg to fetch the selected interval.

These are observations from this run, not guarantees of processing time or input behavior.

Step 2: Asking for a schema instead of prose

The most useful feature was the json_schema parameter in jockey_query. Prose still requires copying and cleanup. A schema returns data the next stage can use.

Rank	Segment	Candidate title	Hook
1	3:24–4:01	Why Do We Use Git at All?	Introductory concept
2	6:39–7:19	Git’s Three Stages as a Delivery Service	Analogy
3	8:00–8:40	Why You Should Not Type git add . Carelessly	Mistake warning
4	11:41–12:12	What Is the Difference Between Git and GitHub?	Common confusion
5	14:43–15:20	Clone, Fetch, and Pull in 30 Seconds	Comparison

All five candidates in this single trial landed on complete conceptual boundaries. This does not guarantee the same result for every video. It does show that Jockey was useful for narrowing a lecture by meaning and structure.

Step 3: Correcting subtitles twice

Several transcript sentences shared the same roughly eight-second time window. Used as-is, multiple subtitle lines would appear and disappear together.

I redistributed each window in proportion to sentence length. If an 8.13-second window contained sentences of 20, 22, 24, and 36 characters, they received about 1.59, 1.75, 1.91, and 2.87 seconds. This was not phoneme-level alignment, but it looked natural in this short clip.

Korean ASR also distorted technical names. The raw transcript was not suitable for direct publication. Constrained LLM cleanup—preserving meaning while correcting technical terms and grammar—made it usable.

• Jockey found conceptual boundaries and candidate segments.
• Post-processing redistributed sentence timing.
• LLM cleanup corrected terminology and grammar.
• A human checked the final frames and subtitles.

Step 4: Building the vertical edit

ffmpeg -ss 204.93 -i "https://.../playlist.m3u8" -t 36.54 \
  -c:v libx264 -crf 18 -c:a aac clip_raw.mp4

ffmpeg -i clip_raw.mp4 -filter_complex \
  "[0:v]split[s0][s1];
   [s0]scale=1080:1920:force_original_aspect_ratio=increase,
       crop=1080:1920,gblur=sigma=30,eq=brightness=-0.08[bg];
   [s1]scale=1040:-2[fg];
   [bg][fg]overlay=(W-w)/2:(H-h)/2,ass=subs.ass[v]" \
  -map "[v]" -map 0:a -c:v libx264 -crf 19 git_why_shorts.mp4

ASS subtitles provided control over outlines, translucent boxes, and placement. Reusing the video for background and foreground required a split filter.

Step 5: Four frames for final verification

I extracted frames at 2, 10, 20, and 30 seconds. In the 30-second frame, the subtitle referred to git --version while the terminal showed the same command and output.

This did not remove review. It replaced a full rewatch with a short check of representative frames and boundaries.

What to trust and what to check

Confidence	Item	Judgment from this trial
High	Candidate discovery by conceptual boundary	All five candidates were complete segments
High	Natural-language search and transcript retrieval	Useful for locating concepts
Conditional	Candidate start and end times	Check cut boundaries
Conditional	Sentence-level subtitle timing	Redistribute shared windows
Needs correction	Raw Korean ASR	Review technical terms and proper nouns

Discovery timestamps and subtitle timestamps solve different problems. A few seconds may be acceptable for finding a concept; half a second can make subtitles feel wrong.

Cost: about $1.64 under an assumed API-call model

The table applies the Developer rates on the TwelveLabs API pricing page, checked September 1, 2026. It assumes one Marengo indexing pass, two full-video Pegasus Analyze calls, and roughly 3,000 output tokens. It does not claim that one Jockey request maps one-to-one to one API call.

Item	Assumed usage	Public rate	Estimate
Marengo indexing	16.1 min × 1	$0.042/min	$0.68
Pegasus Analyze	16.1 min × 2	$0.0292/min	$0.94
Output text	About 3,000 tokens	$0.0075/1,000 tokens	$0.02
ffmpeg editing	Local	-	$0
Total			About $1.64

Three boundaries matter:

1. It is not an actual Jockey charge. The Jockey product page lists separate storage-based plans.
2. Agent calls can vary, so dashboard usage is authoritative.
3. I excluded the monthly Developer infrastructure rate from this immediate estimate.

The API Free plan’s 600 minutes combine indexing, analysis, and segmentation. That is not the same as Jockey’s free 5 GB knowledge-store plan.

Four lessons

JSON schema was the backbone

Prose ends with a reader. Numeric start and end times can become another tool’s input. Structured output turns conversation into an automatable interface.

Trust belongs to stages, not brands

“Can I trust Jockey?” is too broad. I can trust it to narrow candidates, correct subtitle timing in post-processing, review proper nouns, and reserve final approval for a human.

One video asset can support several later tasks

A lecture can lead to review, short discovery, chapter generation, and question answering. Some functions or engines may require reindexing, so this should not be described as every feature sharing the same index unchanged.

Human work moved from rewatching to approval

I did not remove judgment. I narrowed where it was needed: choose the candidate, inspect representative frames, and approve the result.

What comes next

Candidate selection is the next automation target. Scoring hook strength, duration, and conceptual completeness could select a winner and render the remaining four candidates as a batch.

AI can bring me to “this is the strong part.” A person still decides whether it is ready to upload.

The difference is that I checked four frames instead of watching the 16-minute lecture again.

Environment and sources

• Environment: Claude Cowork, TwelveLabs Jockey MCP, ffmpeg 6.1
• Source: 16:04 introductory Git and GitHub lecture
• Pricing basis: TwelveLabs API Pricing, checked 2026-09-01
• Jockey plans: Jockey
• Product architecture: Video Intelligence Is Going Agentic
• Analyze billing: TwelveLabs FAQ
• Previous report: Building a Lecture Review Pipeline with TwelveLabs Jockey

Jockey was introduced as a research preview. The timing and results here describe one run, not a service-level guarantee.