What Shall We Build Next?

Describe

Describe your task

Refine

Refine the plan

SubAgents

Review all agents

Deploy

Deploy your agent

A) SUBAGENT SUMMARY  
This subagent receives a user’s search query, invokes a live web search, and returns the textual results (pages, URLs, brief snippets) in raw text form.

B) FINAL TASK OUTPUT  
The final output is “[raw-search-results]” – a text-based response containing the search information (titles, URLs, brief snippets or descriptions), still unstructured and unparsed.

C) SUBAGENT INPUT  
• The search query (string)

D) SUBAGENT OUTPUT  
• The unstructured text of search results, labeled as “[raw-search-results]”

E) SUBAGENT TASK SUMMARY  
1) Subagent receives the user’s search query (string).  
2) Call SKILL #224 - “Oracle Ask A Question” with the user’s query as input.  
   - INPUT to #224: string (the user’s query)  
   - OUTPUT from #224: A text response containing pages, URLs, and snippets describing the live search results.  
3) Return the output from skill #224 as the raw search results. Label it as “[raw-search-results]”.

F) SILOS  
• Silo 1: Perform live web search  
   - Uses Skill #224 to fetch and return the textual information.  
• (No further silos needed, as the subagent concludes with returning “[raw-search-results]”).

SubAgent #1 - Diagram

Expand Diagram

A) SUBAGENT SUMMARY  
This subagent takes the raw textual output from the previous subagent’s web search and converts it into a structured list of search results, where each result contains the “title,” “url,” and optional “snippet” attributes.

B) FINAL TASK OUTPUT  
A JSON‐like array (or list) of objects, each containing three keys:  
• title  
• url  
• snippet (optional)

Example:  
[  
  { "title": "...", "url": "...", "snippet": "..." },  
  { "title": "...", "url": "...", "snippet": "..." }  
]

C) SUBAGENT INPUT  
• Text response from Subagent 1 (the raw textual search data).

E) SUBAGENT TASK SUMMARY  
Below is the step-by-step sequence of skills/actions the subagent performs:

1) Receive [raw-search-results] (the text response from Subagent 1).  
2) Pass this text to Skill #223 (Powerful LLM Prompt-to-Text Response), instructing it to parse titles, URLs, and optional snippets from each entry in the text, and return them as a JSON-like array of objects.  
3) Output the structured results as [parsed-search-results].

So the chain looks like:

[raw-search-results]  
  → (Skill #223: parse titles, URLs, snippets)  
  → [parsed-search-results]

F) SILOS  
There is just one broad silo here, the parsing silo. All parsing and structuring is done in a single pass using Skill #223. If more complex validations or intermediate checks are needed, those would also be performed via Skill #223, but for this subagent’s core function, one main parsing pass is typically sufficient.

SubAgent #2 - Diagram

Expand Diagram

A) SUBAGENT SUMMARY:  
This subagent takes the user’s original search query and the structured array of parsed search results, then combines them into a single well-formed JSON string.

B) FINAL TASK OUTPUT:  
One final JSON string/file (named “search_results.json”), with the structure:  
{
  "query": "USER_QUERY",
  "results": [
    {
      "title": "Page Title",
      "url": "https://example.com",
      "snippet": "Short description..."
    },
    ...
  ]
}

C) SUBAGENT INPUT:  
1) The user’s original query (string).  
2) The parsed results array of objects (each object contains title, url, snippet).

E) SUBAGENT TASK SUMMARY:  
Below is the step-by-step flow for assembling the final JSON. This subagent largely relies on one skill (#223 - Powerful LLM Prompt-to-Text Response) to merge the query and results array into a properly formatted JSON string.

1) Subagent Inputs → 2) Use Skill #223 → 3) Subagent Outputs

1) Subagent Inputs:  
   • “USER_QUERY” (string)  
   • “parsed_results_array” (array of objects, each with title, url, optional snippet)

2) Use Skill #223 (Powerful LLM Prompt-to-Text Response):  
   • Prompt the LLM to produce a JSON structure with the following top-level keys:  
     "query" (string)  
     "results" (array of objects)  
   • Instruct the LLM to ensure it returns valid JSON only (no additional text commentary).

3) Subagent Outputs:  
   • The final JSON string:
     {
       "query": "USER_QUERY",
       "results": [...]
     }
   • This string is ready to be saved/downloaded as “search_results.json”.

F) SILOS:  
All tasks in this subagent are performed in a single silo (one skill call) because the assembly process is straightforward:
• Silo 1: JSON Assembly (using skill #223).

SubAgent #3 - Diagram

Expand Flow

A) SUBAGENT SUMMARY  
This (hypothetical) Subagent 4 is responsible for performing a final verification step on the already-assembled JSON data—checking compliance with any format requirements and making sure the JSON is fully valid. It then returns the validated JSON to be saved or passed on.

B) FINAL TASK OUTPUT  
A valid JSON string (or object), fully verified and ready for storage or downstream use. For example:  
{
  "query": "...",
  "results": [
    {
      "title": "...",
      "url": "...",
      "snippet": "..."
    },
    ...
  ]
}

C) SUBAGENT INPUT  
1) The partially assembled JSON from Subagent 3 (Output: [assembled-json-file])  
2) Any additional requirements or instructions for final data quality checks (e.g., “Ensure no duplicate results,” “Verify that URLs are valid,” etc.)

E) SUBAGENT TASK SUMMARY  
Below is the step-by-step outline of how Subagent 4 might do its job. Though no single skill in the list above directly “validates JSON,” we can use a large language model skill (#223) to parse and verify the JSON text.

1) Receive [assembled-json-file] (the JSON string).  
2) Perform a quick validity check using #223 - Powerful LLM Prompt-to-Text Response  
   • Prompt the LLM to parse the incoming JSON string and look for any structural issues or missing fields.  
   • If issues are discovered, either correct them automatically or return an error message.  
   • Example prompt:  
     “Here is a JSON string of search results. Check whether it is valid JSON and meets the required format with a field named ‘query’ (string) and a ‘results’ array of objects (each object has ‘title’, ‘url’, and optional ‘snippet’). If it is invalid, fix it and return valid JSON. If it’s valid, just return it unchanged.”  
3) Return the validated JSON string (unchanged if it was already valid, or corrected if issues were found).

Subagent 4 final output → [validated-json-file]

F) SILOS  
• Silo 1: JSON Input Handling  
  - Input: JSON text from Subagent 3  
  - Action: Send to #223 with a prompt to check/fix format  
  - Output: Verified JSON text

• Silo 2: Final Verified JSON  
  - No further manipulations beyond returning the final corrected JSON.  
  - Output: [validated-json-file]

This concludes the actionable workflow for the (hypothetical) Subagent 4: receiving, validating, and returning the final JSON.

4 Template & Links

Expand Flow

A) SUBAGENT SUMMARY  
This subagent takes in any partially assembled or unstructured search results, refines them (e.g. de-duplicates, optionally re-sorts, etc.), and outputs a final, clean JSON of search results.

B) FINAL TASK OUTPUT  
A single, well-structured JSON (string) that is refined and clean, with any duplicates removed, sorted or otherwise optimized as needed.

C) SUBAGENT INPUT  
• One or more JSON-like strings or objects containing search results that need final refining.  
• Optional instructions (e.g., how to sort, whether to keep duplicates, how to handle missing fields).

E) SUBAGENT TASK SUMMARY  
Below is the step-by-step chain of skills/actions that this subagent will perform.

1) Receive the input JSON (or multiple partial JSONs).  
   – (No skill needed: this is simply the subagent’s starting input.)

2) Combine / merge all partial JSON objects into a single JSON string for the LLM to parse.  
   – (No specific skill call: a light code or data-handling step inside the subagent.)

3) Use skill #223 - Powerful LLM Prompt-to-Text Response  
   Action:  
     • Prompt the LLM to parse the merged JSON and remove duplicates.  
     • If duplicates are found (same title + same URL), the subagent merges them.  
     • Return a newly cleaned data set with no duplicates.  
   Inputs:  
     • The merged JSON string.  
     • Clear instructions: “Remove duplicates and produce valid JSON array of results with fields: title, url, snippet.”  
   Output:  
     • A refined JSON-like text or array of objects with duplicates removed.

4) (Optional) Use skill #223 - Powerful LLM Prompt-to-Text Response again  
   Action:  
     • Prompt the LLM to reorder or re-rank the refined search results as needed (e.g., by relevance, alphabetically, etc.).  
   Inputs:  
     • Current (cleaned) JSON string from Step 3.  
     • Instructions on ranking/sorting (e.g., “Sort descending by relevance, then produce valid JSON.”).  
   Output:  
     • The final sorted/cleaned JSON-like text or array of objects.

5) Subagent returns the final JSON  
   – (Final output from the subagent, returned to the calling workflow.)

F) SILOS  
• Silo 1: JSON Combination & Deduplication  
  – Step 2 (combine partial JSON data)  
  – Step 3 (skill #223 to remove duplicates)

• Silo 2: Optional Sorting/Reordering  
  – Step 4 (skill #223 again to reorder and finalize the data)

• Silo 3: Output  
  – Step 5 (return final, refined JSON string back to the main workflow)

5 Template & Links

Expand Flow

A) SUBAGENT SUMMARY  
This subagent’s job is to take a user’s search query, perform a live web search, parse the returned data (title, URL, snippet), and assemble a finalized JSON output containing the query and a results array.

B) FINAL TASK OUTPUT  
A single JSON string/object in the format below, which can be saved as “search_results.json”:  
{
  "query": "USER_SEARCH_QUERY",
  "results": [
    { "title": "Title1", "url": "URL1", "snippet": "Snippet1" },
    { "title": "Title2", "url": "URL2", "snippet": "Snippet2" }
  ]
}

C) SUBAGENT INPUT  
• A string containing the user’s search term (e.g., "how to bake sourdough").

D) SUBAGENT TASK SUMMARY (Step-by-Step Flow)

1) Receive user input (search query).  
2) Skill #224 - Oracle Ask A Question  
   - INPUT: The user’s search query (string).  
   - OUTPUT: Raw textual search results (titles, URLs, snippets).  
3) Skill #223 - Powerful LLM Prompt-to-Text Response (Parsing)  
   - INPUT: Raw search results text from step 2.  
   - Function: Parse out each individual search result, identifying title, URL, and snippet.  
   - OUTPUT: A structured array (or JSON-like text) of objects with {title, url, snippet}.  
4) Skill #223 - Powerful LLM Prompt-to-Text Response (JSON Assembly)  
   - INPUT: (a) The original user query from step 1, (b) The structured list of parsed results from step 3.  
   - Function: Insert both pieces of data into the final JSON schema →  
     {
       "query": "USER_QUERY",
       "results": [...]
     }  
   - OUTPUT: A single JSON string containing the structured search results.

5) SUBAGENT OUTPUT  
   - The JSON (as text) is returned, ready to be saved to a file named “search_results.json.”

E) SILOS (if helpful to see each stage’s mini-flow)

• Silo 1: Search (Skill #224)  
  1) Input: user query  
  2) Output: raw text describing found pages

• Silo 2: Parse (Skill #223)  
  1) Input: raw text from silo 1  
  2) Output: structured list of results [{title, url, snippet}, …]

• Silo 3: JSON Assembly (Skill #223)  
  1) Input: (a) user query, (b) structured list from silo 2  
  2) Output: final JSON string ready for saving.

6 Template & Links

Expand Flow

7 Template & Links

Expand Flow

8 Template & Links

Expand Flow

9 Template & Links

Expand Flow

10 Template & Links

Expand Flow

11 Template & Links

Expand Flow

12 Template & Links

Expand Flow

Need To Start Afresh?

BACK TO REFINE

Tweaked & Good To Go?

PROCEED TO DEPLOY