# What Is Focused Mode in Claude Video? Analyzing Specific Video Segments Efficiently

> Learn about Claude Video's focused mode. Efficiently analyze specific video segments using start and end timestamps for higher frame density and filtered transcripts. Optimize your video processing.

- Repository: [bradautomates/claude-video](https://github.com/bradautomates/claude-video)
- Tags: explainer
- Published: 2026-07-28

---

**Claude Video’s focused mode automatically activates when you provide `--start` or `--end` timestamps, restricting analysis to a specific time window with higher frame density and filtered transcripts instead of processing the entire video.**

The `bradautomates/claude-video` repository includes a specialized *focused mode* that allows you to zero in on specific segments of a video without incurring the cost of processing the full duration. This feature is particularly useful when you need detailed analysis of a particular scene or time-bound event while keeping token consumption minimal for downstream LLM calls.

## Activating Focused Mode with Timestamps

Focused mode triggers automatically whenever you supply a **start** (`--start`) or **end** (`--end`) timestamp to the `watch` command. In [`skills/watch/scripts/watch.py`](https://github.com/bradautomates/claude-video/blob/main/skills/watch/scripts/watch.py), the tool evaluates whether to enter focused mode using a simple boolean check:

```python
focused = start_sec is not None or end_sec is not None

```

This logic appears at lines 153–155 of [`watch.py`](https://github.com/bradautomates/claude-video/blob/main/watch.py). When `focused` evaluates to `True`, the tool narrows every downstream operation—including frame extraction, transcript parsing, and budget allocation—to the user-specified time window.

## Technical Implementation in the Source Code

### Range Detection and Duration Calculation

When focused mode is active, the system computes `effective_start` and `effective_end` values from the supplied timestamps, clamping them to the video’s actual duration to prevent out-of-bounds errors. Unlike full mode, which uses the entire video length, focused mode treats the segment boundaries as the new domain for all operations.

### Adaptive FPS and Frame Budgeting

One of the key optimizations in focused mode occurs in the frame sampling strategy. According to the source code in [`watch.py`](https://github.com/bradautomates/claude-video/blob/main/watch.py) (lines 55–58), the system calls `auto_fps_focus()` instead of the standard `auto_fps()` function:

- **Full mode**: Calls `auto_fps()` to distribute a uniform frame budget across the entire video duration.
- **Focused mode**: Calls `auto_fps_focus()` to produce a higher FPS and tighter frame budget specifically calculated for the shortened interval.

This adjustment ensures you receive a **compact, higher-resolution view** of the specific segment rather than sparse sampling across the full timeline.

### Transcript Filtering and Cue Frame Handling

In [`skills/watch/scripts/transcribe.py`](https://github.com/bradautomates/claude-video/blob/main/skills/watch/scripts/transcribe.py), the tool filters transcripts to the specified range using the `filter_range()` function (referenced in [`watch.py`](https://github.com/bradautomates/claude-video/blob/main/watch.py) lines 63–66). This preprocessing step removes subtitle or Whisper data that falls outside the window before formatting.

Additionally, cue timestamps derived from the transcript are validated against the focused range. In [`watch.py`](https://github.com/bradautomates/claude-video/blob/main/watch.py) (lines 88–93), any cue frames falling outside the start/end boundaries are dropped and reported, while those inside the window are preserved. The budget is then reduced by the number of cue frames within the range, preventing user-requested segments from being evicted during frame selection.

### Frame Extraction Pipeline

The low-level ffmpeg wrapper in [`skills/watch/scripts/frames.py`](https://github.com/bradautomates/claude-video/blob/main/skills/watch/scripts/frames.py) respects the focused flag for range-limited extraction. Lines 730–752 propagate the `start_seconds` and `end_seconds` values into the extraction functions, ensuring that `extract_scene_or_uniform()` generates frames only within the specified window (referenced in [`watch.py`](https://github.com/bradautomates/claude-video/blob/main/watch.py) lines 95–124).

## Practical Usage Examples

To analyze an entire video without restrictions, use the standard command:

```bash
claude-video watch https://www.youtube.com/watch?v=abc123

```

To activate focused mode and analyze only a 30-second clip from 01:20 to 01:50, include the timestamp flags:

```bash
claude-video watch https://www.youtube.com/watch?v=abc123 \
    --start 1:20 --end 1:50 \
    --detail efficient

```

When you run this command, the output summary displays a **Focus range** line showing the explicit start → end times (as implemented in [`watch.py`](https://github.com/bradautomates/claude-video/blob/main/watch.py) lines 78–84), confirming that the tool is operating in focused mode rather than "full" mode.

For programmatic use within the package, you can leverage the same logic directly:

```python
from skills.watch.scripts.watch import parse_time, auto_fps_focus

# Define your segment boundaries

start = parse_time("1:20")  # → 80.0 seconds

end = parse_time("1:50")    # → 110.0 seconds

# Calculate adaptive FPS for the shortened duration

if start is not None or end is not None:
    fps, target = auto_fps_focus(end - start, max_frames=4000)
    
    # Extract frames only within the window

    frames, meta = extract_scene_or_uniform(
        video_path,
        work_dir,
        fps=fps,
        target_frames=target,
        start_seconds=start,
        end_seconds=end
    )

```

## Summary

- **Focused mode** activates automatically when you provide `--start` or `--end` timestamps to the `watch` command in Claude Video.
- The system uses `auto_fps_focus()` in [`frames.py`](https://github.com/bradautomates/claude-video/blob/main/frames.py) to allocate higher frame density to shorter segments, providing detailed analysis without processing the full video.
- Transcripts are pre-filtered using `filter_range()` in [`transcribe.py`](https://github.com/bradautomates/claude-video/blob/main/transcribe.py) to include only dialogue within the specified window.
- Frame extraction in [`frames.py`](https://github.com/bradautomates/claude-video/blob/main/frames.py) (lines 730–752) respects the segment boundaries, passing `start_seconds` and `end_seconds` to ffmpeg to limit processing scope.
- This mode reduces token consumption for downstream LLM calls while preserving transcript-anchored cue frames inside the analysis window.

## Frequently Asked Questions

### How do I know if focused mode is active when running a command?

The tool reports the active mode in the console output. According to [`watch.py`](https://github.com/bradautomates/claude-video/blob/main/watch.py) (lines 78–84), focused mode displays a **Focus range** line indicating the explicit start and end times (e.g., "Focus range: 80.0s → 110.0s"), whereas full mode shows "full <duration>s" without range constraints.

### Does focused mode affect the quality of frame analysis?

Yes, focused mode typically improves the quality of analysis for the specific segment by invoking `auto_fps_focus()` instead of `auto_fps()`. This function allocates a higher frames-per-second rate and tighter frame budget to the shortened interval, resulting in more granular visual data for Claude to analyze within the specified window.

### Can I use focused mode with existing transcripts or only with Whisper-generated ones?

Focused mode works with both subtitle files and Whisper-generated transcripts. In [`transcribe.py`](https://github.com/bradautomates/claude-video/blob/main/transcribe.py), the `filter_range()` function processes whichever transcript source is available, filtering the content to the specified time range before the data is formatted and sent to the LLM.

### What happens if my start or end timestamp exceeds the video duration?

The system clamps the timestamps to the video’s actual duration. In [`watch.py`](https://github.com/bradautomates/claude-video/blob/main/watch.py), the code computes `effective_start` and `effective_end` values that respect the video boundaries, ensuring that requests for timestamps beyond the video length do not cause errors but instead analyze from the beginning or up to the end of the available footage.