What Shall We Build Next?

Describe

Describe your task

Refine

Refine the plan

SubAgents

Review all agents

Deploy

Deploy your agent

A) SUBAGENT SUMMARY  
“URL Intake” converts whatever the user gives it (single URLs, a comma-separated list, or one or more YouTube playlist links) into a clean JSON file that contains at most five unique, fully-qualified YouTube video URLs.

B) FINAL TASK OUTPUT  
urls.json – UTF-8 JSON text file whose sole content is an array of between 1 and 5 distinct YouTube video URLs, e.g.  
["https://www.youtube.com/watch?v=dQw4w9WgXcQ", …]

C) SUBAGENT INPUT  
{variable1} – Free-form text supplied by the user that may contain:  
• one or more direct YouTube video links  
• one or more YouTube playlist links  
• a CSV / line-break list containing either of the above

E) SUBAGENT TASK SUMMARY  
{variable1}  
 → Skill #223 (Powerful LLM Prompt-to-Text) – “Detect and separately list every direct-video URL and every playlist URL contained in the input.  Return JSON with keys {videos:[], playlists:[]}.”  
  OUTPUT: parsed-urls.json-like text {parsed_list}

{parsed_list} (if playlists array is NOT empty)  
 → Skill #224 (Oracle Ask A Question) – For EACH playlist URL ask:  
  “Give me the first 15 full YouTube video URLs that belong to this playlist (in original order).”  
  OUTPUT: txt list {playlist_videos_X}

All {playlist_videos_X} + {parsed_list.videos[]}  
 → Skill #223 – “Merge all provided video URLs, remove duplicates, keep original order, retain only the first five.  Return the result as a pure JSON array (no keys, no commentary).”  
  OUTPUT: clean-array.txt {final_url_array}

{final_url_array}  
 → Skill #185 (Write Text) – “Save the supplied JSON array verbatim to a file named urls.json.”  
  OUTPUT: urls.json  ← (this is the subagent’s declared final output)

F) SILOS

Silo 1 – Parse Raw Input  
 • #223 …produce {parsed_list}

Silo 2 – Expand Playlists (conditional; runs only when playlists exist)  
 • Loop over playlists with #224 …produce {playlist_videos_X}

Silo 3 – Consolidate & Limit  
 • #223 …produce {final_url_array}

Silo 4 – Persist to File  
 • #185 …produce urls.json

The chain guarantees that whatever the user types, the subagent returns a single machine-readable urls.json file containing up to five valid YouTube video links, ready for the next subagent.

SubAgent #1 - Diagram

Expand Diagram

A) SUBAGENT SUMMARY  
“MP4-Downloader” takes the list of YouTube links produced by Sub-agent 1, saves up to five of those videos as local .mp4 files in a user-chosen folder, and then writes a machine-readable log and a short human-readable summary of what was downloaded.

B) FINAL TASK OUTPUT  
• 1-5 original-quality H.264/AAC .mp4 files, each saved in the chosen directory  
• download_log.json – UTF-8 JSON file: `[ { "url": "...", "local_path": "...", "file_size_bytes": n } … ]`  
• download_summary.txt – ≤ 400-word UTF-8 text file listing titles/filenames, individual sizes, total count and total size.  
(All three output types reside in the destination folder and are returned as the sub-agent’s terminal artefacts.)

C) SUBAGENT INPUT  
• [urls.json] – path to the JSON array of ≤ 5 YouTube URLs created by “URL Intake”.  
• {variable2} – absolute path to a writable local folder (may be empty if the user has not supplied one yet).

E) SUBAGENT TASK SUMMARY (skill chain)  
1. Destination-folder check  
   • IF a file called dest_folder.txt exists → read its contents as DEST_PATH.  
   • ELSE → prompt the user for a writable folder (uses ordinary agent I/O, not a skill) → store response in {variable2}.  
   • Validate {variable2} with #223 Powerful LLM (“Does ‘{variable2}’ look like a valid writable path on this OS? Answer YES/NO”).  
   • If YES → write that path to dest_folder.txt → set DEST_PATH = {variable2}.  
   • If NO → re-prompt until a valid path is supplied.

2. Load URL list  
   • Read urls.json into memory as URL_LIST (array length ≤ 5).

3. Download loop (repeat for each url in URL_LIST)  
   • Call internal skill **#194 – “Download YouTube Video As MP4”**   
     INPUT: {url, DEST_PATH}  
     OUTPUT: absolute local path of saved .mp4 (MP4_PATH)  
   • Collect `{ "url": url, "local_path": MP4_PATH, "file_size_bytes": FILE_SIZE }` into DOWNLOAD_ARRAY.  
     (FILE_SIZE acquired with a trivial filesystem stat; no extra skill required.)

4. Write machine log  
   • Use #223 to format DOWNLOAD_ARRAY as pretty-printed JSON → save as download_log.json in DEST_PATH.

5. Create human summary  
   • Prompt #223: “Create a concise, human-readable summary of these downloads: {DOWNLOAD_ARRAY}. Include video filenames (strip extension for ‘title’), file sizes in MB (one decimal place), total count, and combined size.”  
   • Save the response as download_summary.txt in DEST_PATH.

6. Return final outputs  
   • Return the set { all MP4_PATHs, DEST_PATH/download_log.json, DEST_PATH/download_summary.txt } as [downloaded-youtube-mp4s].

F) SILOS

SILO 1 – Folder Handling  
   Steps 1 (dest_folder.txt logic, validation)

SILO 2 – Video Acquisition  
   Steps 2–3 (load urls.json, loop through URL_LIST calling #194)

SILO 3 – Reporting  
   Steps 4–5 (build log with #223, create summary with #223)

This flow keeps the original concept intact, corrects the earlier mis-numbering (clarifying that the YouTube-to-MP4 downloader is the dedicated #194 internal skill), validates user input, and cleanly separates folder handling, downloading, and reporting into three logical silos.

SubAgent #2 - Diagram

Expand Diagram

A) SUBAGENT SUMMARY:  
“Video Validator & Preview-Maker” – after the videos are downloaded it checks that every MP4 really opens, extracts one thumbnail from each file, and writes a short integrity/preview report.

B) FINAL TASK OUTPUT:  
• integrity_report.txt – UTF-8 text file that lists, for each MP4, the YouTube URL, local file path, “OK / ERROR” status, and the PNG path of the first extracted thumbnail.  
• 1 PNG thumbnail (≈1400 × 2800 px) per MP4, saved in the same destination folder.

C) SUBAGENT INPUT:  
[download_log.json] // created by Subagent 2; contains array of {url, local_path} pairs

E) SUBAGENT TASK SUMMARY (skill chain)

1. Read download_log.json → in-memory list of ≤ 5 {url, mp4_path}.  
2. FOR EACH mp4_path:  
   a. #202 Extract Thumbnail Images Of MP4  
      INPUT: mp4_path, prompt: “Extract the first clear frame to verify the file saved correctly.”  
      OUTPUT: 10 thumbnail URLs.  
   b. Keep the first thumbnail URL; note success (“OK”); if #202 throws an error note status “ERROR – cannot open”.  
3. After loop finishes, assemble a plain-text table containing URL, mp4_path, status, thumbnail_path.  
   • #223 Powerful LLM Prompt-to-Text  
     INPUT: the collected table data with the instruction “Format this as a tidy human-readable integrity report.”  
     OUTPUT: integrity_report.txt text.  
4. Save integrity_report.txt in the same folder that holds the MP4s.

F) SILOS

SILO 1 – per-video validation  
 download_log.json entry → #202 thumbnail extraction → single thumbnail PNG + status flag

SILO 2 – consolidation  
 all status lines → #223 → integrity_report.txt

SubAgent #3 - Diagram

Expand Flow

A) SUBAGENT SUMMARY  
“Thumbnail & Metadata Extractor” – generates high-quality thumbnail images and a quick-look metadata report for every MP4 that was downloaded in Subagent 2.

B) FINAL TASK OUTPUT  
• 10 thumbnail image files (PNG/JPG, 1400 × ? px as produced by the skill) per video, saved in the same destination folder  
• thumbnails_log.json – JSON array [{mp4_local_path, youtube_url, [thumbnail_urls…]}]  
• thumbnails_summary.txt – human-readable list of every video with title, file-size, and the first thumbnail URL

C) SUBAGENT INPUT  
[download_log.json] – produced by Subagent 2 and containing the mapping {url, local_path} for each downloaded MP4

E) SUBAGENT TASK SUMMARY

download_log.json  
  ↳ loop through each {url, local_path} (max 5)  
     → Skill #202 “Extract Thumbnail Images Of MP4 Video”  
        INPUT: mp4_local_path, prompt: “Extract the 10 most representative frames for a YouTube video I have just downloaded; optimise for good visibility of the subject.”  
        OUTPUT: list_of_10_thumbnail_urls  
     → Append result to in-memory array thumbnails[] as {mp4_local_path, youtube_url, thumbnail_urls}

After loop completes  
  → write thumbnails[] to thumbnails_log.json (internal file-write)

→ Skill #223 “Powerful LLM Prompt-to-Text Response”  
     INPUT: “Using the following JSON, create a concise plain-text summary showing ❶ video title (from file name), ❷ file size in MB, ❸ first thumbnail URL. JSON:\n<<thumbnails[]>>”  
     OUTPUT: thumbnails_summary_txt

→ save text to thumbnails_summary.txt

Subagent returns: the newly saved thumbnail image files, thumbnails_log.json, thumbnails_summary.txt

F) SILOS

SILO 1: PER-VIDEO PROCESS  
download_log entry → #202 → collect thumbnail URLs

SILO 2: CONSOLIDATION  
aggregate thumbnails[] → write thumbnails_log.json → #223 → thumbnails_summary.txt