A/B test three Shorts hooks from one body: Timeline source_in

YouTube's Made on YouTube 2026 roundup lists Video A/B testing that lets a creator test up to three versions of a Short to see which performs best, marked as coming soon. You can prepare the three files now: keep one body, swap the first few seconds, and render each version as its own Timeline 1.0 job, with the unbilled plan call to check length and price first.

The YouTube item comes from a third-party roundup, read on 2026-10-03, and I did not find YouTube's own page for it. The Sume side comes from the Timeline 1.0 doc.

What exactly was announced?

The roundup lists, under Shorts: Shorts Series (rolling out now), Video A/B testing for up to three Shorts versions (soon), and conversational video editing (early 2027 on Android and iPhone). Nothing in it says how the three versions are uploaded or compared, so treat the plan below as preparation, not as a documented workflow.

How do I build three versions from one body?

Each version is one Timeline program: a hook slot, then the shared body. A slot has source_url, start (position on the audio spine), duration and an optional source_in into the file. If the three hooks are separate short clips and the body is one file, the body slot's start equals the hook's length, and source_in is where the body begins in its file.

• Hook A, B and C: three clips of the same length, so the body lands at the same time in all three.
• One body file, source_in set once.
• One audio spine per version if the hook is spoken, or one shared spine if only the picture changes.
• Keep the transition identical, for example a 0.25-second fade, so the only variable is the hook.

How do I check price and length before rendering?

Call the plan endpoint, which is unbilled, takes no idempotency key, and returns duration_seconds, segment_count, billable_minutes and estimated_cost_usd_micros. This script plans the three versions; it assumes the hooks and body are already imported to your media host.

import os, requests

API = "https://api.sume.com"
H = {"Authorization": f"Bearer {os.environ['SUME_API_KEY']}"}
BODY = "https://media.sume.com/artifacts/artf_demo/body.mp4"
AUDIO = "https://media.sume.com/artifacts/artf_demo/spine.wav"
HOOKS = {
    "a": "https://media.sume.com/artifacts/artf_demo/hook-a.mp4",
    "b": "https://media.sume.com/artifacts/artf_demo/hook-b.mp4",
    "c": "https://media.sume.com/artifacts/artf_demo/hook-c.mp4",
}

def main():
    for name, hook in HOOKS.items():
        body = {
            "audio": {"url": AUDIO, "duration_seconds": 30},
            "video": [
                {"source_url": hook, "start": 0, "duration": 3},
                {"source_url": BODY, "start": 3, "duration": 27,
                 "source_in": 4, "transition": {"type": "fade", "duration": 0.25}},
            ],
        }
        r = requests.post(f"{API}/v1/timeline-1.0/plan", headers=H, json=body)
        r.raise_for_status()
        p = r.json()
        print(name, p["duration_seconds"], p["billable_minutes"], p["estimated_cost_usd_micros"])

main()

What does the test cost?

Timeline 1.0 is $0.10 per ceil output minute, so three versions of a 30-second Short are 3 x $0.10 = $0.30. A 61-second version bills two minutes. The plan call cannot predict warnings for short sources that get padded or looped, so read the warnings[] on the real result.

If the hook is a new cut of the same footage, make it with video trim at $0.02 a job, then place the result at source_in 0.

What Sume does not do

Sume does not run the A/B test, does not upload the versions, and does not read YouTube analytics. It makes three consistent files; the comparison happens in YouTube Studio once the feature ships.