Our own AI film studio. The GPU bill is $0.

Our CosmosFull test generated 121 frames at 720 × 1280 and 24 fps. The request took 275.76 seconds, including 275.47 seconds of inference, and used up to 139,714 MiB of GPU memory. Other shots may take longer or finish sooner.

Modal's 8 October list prices were $0.001736/s for a B200, $0.0000131/s per physical CPU core and $0.00000222/s per GiB of RAM. Our four-core, 128-GiB configuration totals $0.00207256/s; the cost estimates here use the approximate rate of $0.0020725/s. At that rate, generation is $0.5715126, loading is $0.168017575, and a full 90-second warm tail is $0.186525. The chart adds model loading and one full tail to the batch, then divides by its take count.

Modal bills for model loading and the time a worker waits idle before shutting down. We call that the warm tail. Keeping the weights on a persistent volume avoids downloading them each time; batching spreads startup costs across more takes. Stopping the worker sooner can reduce idle charges. The chart assumes one loaded worker making takes in sequence; parallel workers can each incur those costs.

The $0 figure covers GPU charges. Voice, image generation, music, Claude calls, storage, subscriptions, local compute, publishing and our time fall outside that figure. Future GPU usage may need fresh credits or cash. Modal's startup program lists the eligibility rules and how to apply. AWS, Google Cloud and Azure credits do not directly cover Modal usage.

The earlier $184 week was actual cash spent on hosted APIs, including rejected takes and experiments beyond those twelve films. Our newer ledger estimates grant-funded compute, including tests and repairs. The totals cover different work and measure different kinds of spending.

Our research tool makes a dense sheet of the first three seconds at four frames per second, a whole-film sheet at 1.5-second intervals, scene-cut notes and a local transcript. Agents read them together: what is promised at the opening, what makes the next beat necessary, and where the answer arrives.

Our own review separates the hook, the transition into the story, the body and the ending. It compares platform-specific results with earlier medians and marks posts under 24 hours old as early. Retention curves led us to inspect the seconds after the last spoken line and shorten the ending. That is an editing hypothesis, not proof that the change increased reach.

The brief links each claim to its source and states what that source can establish. A missing payment can become an empty tray beside a stamped form. Public counters are snapshots; these small observational studies have not given us a reliable forecast of a film's reach. The research tools are part of our private engine, separate from the public generation helper below.

Each film.json project keeps the narration with its cast references. It saves the motion prompts and selected clip windows, plus captions and sound. Sources and posting details live there too. The Python engine can pick up from a saved stage. The GPU app we inspected loads weights from a persistent volume, starts vLLM-Omni in its container and calls 127.0.0.1/v1/videos/sync. It sends the finished video back to the local project. Mounting an output volume does not by itself prove that a video was saved there.

The latest integration defaults to modal-full. Earlier projects used different defaults and lower resolutions. We still need to check the running worker: its settings can differ from the source.

Each model class has its own container limit. The studio code we inspected has no shared limit across all GPU workers. The source notes below list the full model revisions and runtime image.

Full-model settings · example request

model:          Cosmos3-Super-Image2Video
steps:          50
guidance_scale: 6.0
flow_shift:     5.0
width:          720
height:         1280
num_frames:     121
fps:            24
seeds:          [7, 21, 42, 99]
local_workers:  2

These are the whole-clip confidences from the archived run. The failure rule is ≥ 0.20. A high score means stronger confidence in a defect, not better video quality.

The two original-frame-rate windows cover frames 3–27 and 57–81, inclusive. Their highest defect confidences are 1.0 and 0.7773. The saved record reports 71 video frame appearances. The exact input receipt was not retained; the stored window bounds and answers are available in the record below. Three first-versus-later still comparisons were recorded separately, outside that counter. The archived quality score is 0.0, on a separate scale from these defect confidences.

Download the saved answers and thresholds. The source pictures and clip belong to this same archived preview; they are separate from our newer native-720p gallery.

The archived preview has 121 decoded frames and 120 neighboring frame pairs. Qwen saw 71 frame appearances across its samples and windows. Some window frames also appear in the whole-clip samples, so a source frame can be shown more than once. Its highest window confidence at the original frame rate was 1.0.

The hard-cut rule fires at warped LPIPS ≥ 0.40 or occlusion share ≥ 0.90. A one-second freeze also fails. Qwen's Yes/No scores are not calibrated probabilities that its answer is correct. The ranker cannot explicitly reject every take; if it errors or times out, selection falls back to the highest quality score.

• Default v1 gateFail at whole-clip defect confidence ≥ 0.20, window defect confidence ≥ 0.50, a dense hard cut or occlusion jump, or a one-second freeze. A failed take's quality score is capped at 49.
• Take eligibilityThe selector asks for both a passing verdict and a quality score of at least 90.
• Ranking viewFive frames at one fps, resized to 270 × 480, with candidate rows shuffled. Claude chooses a letter and explains why.

Today's ranker sees five thumbnails one second apart. That still leaves action unseen. These are older 480 × 832 clips, from the preview model (A, seed 7) and full model (B, seed 21). They illustrate an editing decision, not a controlled model benchmark.

Tracking a take and its final edit · pseudocode

intent = SHA256(image + prompt + negative_prompt + seed
                + model + app_class + width + height + frames + fps)

proof = {
  video_sha256: SHA256(returned_mp4),
  measured:     probe(returned_mp4),
  requested:    generation_contract
}

selected_sha256 == winner_sha256
reviewed_delivery_sha256 == uploaded_delivery_sha256

1. Prepare the model. Use the NVIDIA serving instructions with the full-model revision pinned below. On Modal, keep the weights on a persistent volume and load them once per worker. Our configuration is B200, four CPU cores and 128 GiB RAM.
2. Generate four takes. Download the request helper and example prompt. Supply a 720 × 1280 PNG keyframe. The helper sends the 720 × 1280, 121-frame request with seeds 7, 21, 42 and 99, saving each MP4 with its timing and hash.
3. Inspect, then edit. Review every take for changing faces, broken hands, missing props and the requested action. Our automated critic helps with the defect checks; Claude compares the survivors. Cut to the narration and review the finished file.