Instruction:
A chat. Create a step-by-step plan to answer the following question using the available tools. Each step should be followed by an evidence variable which will store the output of the function called in that step.

Available Tools:
Bing[input]: A tool that uses Bing search engine to find information related to the input query. It provides a list of websites that may contain the required information.
TextExtractor[input]: Extracts text from one or more web pages provided as newline delimited links in the input string and produces plain text output containing the content of these pages.
LinkCollector[input]: Collects all the links present in the given plain text and returns them as a newline separated list.
QAModel[input]: This is a Question Answering model that can answer questions based on an input passage of text. The input must be a text question that references an :evidence[n]: variable, e.g., What color is the cat, given :evidence1:?

The output format should be:
Plan: [first action]
:evidence0: = [function call with input parameter]
Plan: [next action, based on result of :evidence0:]
:evidence1: = [next function call with input parameter, which might include reference to previous evidence, e.g., "Given context :evidence0"]
...
Answer: [:evidence[n]: containing the final answer.]

Question: Who was the architect of the Sydney Opera House and what are some notable works they have done besides this?


Instruction:
A chat. Develop a plan to generate a solution to the user instruction using the following tools. For each plan, provide an evidence value which will be the output of one of the available functions given an input string.

These are the tools that can be utilized:
WebCrawler[input]: Tool that allows the user to search for information across the internet. It provides a list of sites that might contain the answer to the user's query.
ContentScraper[input]: Load one or more websites from the input string containing newline-delimited links. Input is one or more links, and it outputs plain text containing the content of the links.
URLExtractor[input]: Extracts links from plain text and generates a plain text, newline-delimited response of links.
QuerySolver[input]: Question-answering model, particularly effective at answering questions based on an input passage of text. The input must be a text question that refers to a #fact[n] variable, e.g., What color is the dog, given #fact1?

The input to each function should just be a plain string, without quotes or "+" to concatenate a string with a fact variable, e.g., QuerySolver[What is the capital of Spain, given #fact3?]

Ensure to include only one evidence output per plan step.

The output should be in this format:
Plan: [first action to take based on the input question]
#fact0: = [function to call with input parameter]
Plan: [next action to take, based on result of #fact0:]
#fact1: = [next function to call and input parameter, which may include reference to previous evidence, e.g., "Given context #fact0"]
...
Final Answer: [#fact[n]: containing the final answer.]

Question: Who is the director of the movie 'Inception' and what are some other movies they have directed?


Instruction:
A chat. Develop a systematic plan to solve the following user query, employing the provided tools. Each step in your plan should correspond to an evidence value, which is the output of a specific function given an input string that could be the user's question, prior evidence values, or a combination of both.

These are the tools at your disposal:
DuckDuckGo[input]: A tool enabling users to perform searches via DuckDuckGo. It helps locate potential sites that might hold the answer to the user's query. However, this function does not provide direct answers but lists possible sites that might contain them.
SiteLoader[input]: Fetches one or multiple websites from an input string comprising newline-separated links. The input includes one or more links, while the output consists of plain text encompassing the content of these links.
URLExtractor[input]: Retrieves links from plain text, generating a plain-text, newline-separated response of links.
ALICE[input]: A question-answering language model adept at providing answers based on a given text passage. The input needs to be a textual question referencing an :evidence[n]: variable, such as "What color is the dog, given :evidence1:?"

Each function's input should simply be a plain string, devoid of quotation marks or "+" for concatenating a string with an evidence variable, like ALICE[What is the population of Tokyo, given :evidence3:?]

Ensure that every plan step includes just one evidence output.

Your output should follow this format:
Plan: [initial action to undertake based on the input question]
:evidence0: = [function to invoke with its input parameter]
Plan: [subsequent action to execute, depending on the outcome of :evidence0:]
:evidence1: = [the next function to call along with its input parameter, possibly referring to preceding evidence, e.g., "In light of :evidence0"]
...
Final Answer: [:evidence[n]: that contains the ultimate answer.]

Question: Which company manufactured the first smartphone and when was it released?


Instruction:
A chat. Create a sequential plan to respond to the following user query using the listed tools. Each step should provide evidence that can be used in subsequent steps.

Available Tools:
DuckDuckGo[input]: A tool that performs a web search using DuckDuckGo.
SiteReader[input]: Loads content from specified URLs and provides it as plain text.
URLExtractor[input]: Pulls all URLs from provided text.
ELIZA[input]: A natural language processing tool capable of answering questions when provided with contextual information.

Output Format:
Plan: [First action]
#E1 = [Function to call with parameters]
Plan: [Subsequent action]
#E2 = [Next function to call with parameters (can refer to prior evidence)]
...
Final Answer: #En

Question: How does photosynthesis work and what role do chloroplasts play in this process?


Instruction:
A chat. Develop a sequential plan to solve the following query using the provided tools. Each step should generate an evidence variable that can be used in subsequent steps.

Tools available:
BingSearch[input]: Searches Bing for information related to the input query.
PageReader[input]: Reads the contents of a webpage from a given URL.
LinkFinder[input]: Finds all URLs in a block of text.
InfoMaster[input]: Answers questions based on a given context. The input must be a question referencing a #E[n] variable, such as "What is the capital of France, given #E1?"

Output Format:
Plan: [Action based on input question]
#E1 = [Function to call with input parameters]
Plan: [Next action based on result of #E1]
#E2 = [Next function to call with input parameters, possibly referencing previous evidence]
...
Final Answer: #E[n]

Question: How did the Spanish Flu pandemic end and what lessons were learned from it?


Instruction:
A chat. Devise a systematic plan to respond to the user query leveraging the supplied tools. Every step should coincide with an evidence value, which is the product of one of the available functions given an input string that could be the user question, past evidence values, or a mixture of both.

These are the tools at your disposal:
EncyclopediaSearch[input]: Lets the user search for information from an online encyclopedia. It's beneficial for obtaining knowledge about various subjects.
PageCrawler[input]: Loads one or more webpages from the input string containing newline divided links, where input is one or more links, and creates plain text output encompassing the content of the links.
LinkUnpacker[input]: Unpacks links from plain text and forms a plain text, newline divided response of links.
InquiryProcessor[input]: A question-answering language model, suitable for responding to inquiries based on an input text passage. The input has to be a text question pointing to an :evidence[n]: variable, e.g., What is the GDP of India, given :evidence1:?

The output should comply with this template:
Plan: [primary action to execute based on input question]
:evidence0: = [function to trigger with input parameter]
Plan: [ensuing action to execute, grounded on the result of :evidence0:]
:evidence1: = [next function to trigger and input parameter, which may hint at former evidence, e.g., "Taking into account context :evidence0"]
...
Answer: [:evidence[n]: possessing the final answer.]

Question: What is the life cycle of a butterfly and how does it contribute to pollination?


Instruction:
A chat. Please create a step-by-step plan to generate an ideal response to the user instruction, making use of a set of available tools. Each plan will have a corresponding evidence value, which will be the output of one of the available functions given an input string that can be the user question, one or more previous evidence values, or a mixture of both.

Here are the tools available to be called:
Bing[input]: Tool that allows the user to search for information using the Bing search engine. This tool is useful in finding an appropriate list of sites that may or may not include the answer to the user's question.
ScraperTool[input]: Load one or more websites from the input string containing newline delimited links, where input is one or more links, and produces plain text output containing the content of the links.
LinkFinder[input]: Extract links from plain text and produces a plain text, newline delimited response of links.
QAModel[input]: Question answering language model, particularly useful in answering questions based on an input passage of text. The input must be a text question that references an :evidence[n]: variable.

The output should be in format:
Plan: [first action to take based in input question]
:evidence0: = [function to call with input parameter]
Plan: [next action to take, based on result of :evidence0:]
:evidence1: = [next function to call and input parameter, which may include reference to previous evidence]
...
Answer: [:evidence[n]: containing the final answer.]

Question: What are some notable works by the author who wrote "Pride and Prejudice"?


Instruction:
A chat. Please create a step-by-step plan to generate an ideal response to the user instruction, making use of a set of available tools. Each plan will have a corresponding evidence value, which will be the output of one of the available functions given an input string that can be the user question, one or more previous evidence values, or a mixture of both.

Here are the tools available to be called:
SearchEngine[input]: Tool that allows the user to search for information using a general search engine. This tool is useful in finding a list of sites that may contain the answer to the user's question.
WebScraper[input]: Load one or more websites from the input string containing newline delimited links, where input is one or more links, and produces plain text output containing the content of the links.
LinkExtractor[input]: Extract links from plain text and produces a plain text, newline delimited response of links.
QAModel[input]: Question answering model, particularly useful in answering questions based on an input passage of text. The input must be a text question that references an :evidence[n]: variable.

The output should be in format:
Plan: [first action to take based in input question]
:evidence0: = [function to call with input parameter]
Plan: [next action to take, based on result of :evidence0:]
:evidence1: = [next function to call and input parameter, which may include reference to previous evidence]
...
Answer: [:evidence[n]: containing the final answer.]

Question: What is the current population of Tokyo and what are some famous landmarks?


Instruction:
A chat. Create a detailed execution plan to solve the problem mentioned below, making use of the set of tools available. Each step in your plan should produce an evidence value, which will be the output of one of the available functions given an input string.

Available Tools:
GoogleSearch[input]: A tool that lets you search for information online via Google. It provides a list of potential sources but does not provide direct answers.
PageLoader[input]: Loads a webpage from the input URL and returns the full text of the page.
URLFinder[input]: Finds URLs within a block of text and returns them as a newline-separated list.
InfoBot[input]: A tool that answers questions based on a given context. The input should be a question that refers to an #E[index] variable.

Your output should follow this format:
Plan: [First action based on the question]
#E1 = [Function to call with input]
Plan: [Next action based on the result of #E1]
#E2 = [Next function to call with input, possibly referring to previous evidence]
...
Final Answer: #E[n]

Question: Who invented the telephone and what was their motivation behind it?


Instruction:
A chat. Create a sequential plan to solve the following problem, each step must involve calling one of the available tools and storing its output as evidence. You can refer to previously stored evidence in subsequent steps.

Available Tools:
DuckDuckGo[input]: A tool that lets you perform searches on DuckDuckGo. It returns a list of URLs that might contain the answer to your query.
Readability[input]: A tool that extracts readable content from a webpage. Input is a URL and it outputs the main body text of the page.
QAModel[input]: A language model designed to answer questions. It takes a question where the context can reference previous evidence variables.

Output Format:
Plan: [Describe the first step]
#E1 = [Tool to call with input]
Plan: [Describe the next step based on #E1]
#E2 = [Next tool to call with input possibly referencing #E1]
...
Final Answer: #En

Question: Who wrote the book 'To Kill a Mockingbird' and what are some interesting facts about them?


Instruction:
A chat. Create a step-by-step plan to answer the following user query using the tools provided. Each tool should be used at least once and each plan should have an associated evidence value.

Available Tools:
1. DuckDuckGo[input]: A search engine that can be used to find information on any topic. The input is a string of text, which it uses to return relevant web pages.
2. TextParser[input]: This tool takes in a large amount of text and extracts key pieces of information from it. It's useful for summarizing or extracting specific details from lengthy texts.
3. AskJeeves[input]: This is a question-answering tool that can provide answers to direct questions based on common knowledge or given context.
4. LinkCollector[input]: Extracts all links from a piece of text. Useful when you want to further explore resources mentioned in a document or webpage.

The output format should be as follows:
Plan: [first action]
#E1 = [function with input parameter]
Plan: [next action]
#E2 = [next function with input parameter]
...
Final Answer: #En

Question: Who won the Nobel Prize in Literature in 2020 and what are their most famous works?


Instruction:
A chat. For the following tasks, make plans that can solve the problem step-by-step. For each plan, indicate which external tool together with tool input to retrieve evidence. You can store the evidence into a variable #E[index] that can be called by later tools.

Here are the tools available to be called:
Wikipedia[input]: Tool that allows the user to search for information from Wikipedia.
QA[input]: Tool that can answer questions either directly from common sense and general world knowledge, as well as answering questions given input context that may contain the answer.

Each plan should be followed by exactly one evidence (#E[index]) value.

The output should be in format:
Plan: [first action to take based in input question]
#E1 = [function to call with input parameter]
Plan: [next action to take, based on result of #E1]
...
Final answer: #E[n]

Question: What is the significance of the Battle of Waterloo and who were the key figures involved?


Instruction:
A chat. Make a plan to determine the most popular tourist attractions in Paris, France.

Available tools:
- TravelGuide[input]: Provides information about popular destinations in a specified location.
- ReviewAnalyzer[input]: Analyzes reviews to determine popularity and satisfaction rates.
- QA[input]: Answers questions using general world knowledge or provided context.
- PopularityMeter[input]: Measures the popularity of a place or thing based on various factors.
- ListSorter[input]: Sorts a list based on certain criteria such as popularity or relevance.

Follow the same output format as described in TSK 1 and TSK 2.


Instruction:
A chat. Create a step-by-step plan to answer the following user question, using the tools provided. Each step in your plan should correspond to an evidence value, which will be the output of one of the available functions given an input string that can be either the user's question, previous evidence values, or both.

Here are the tools you have at your disposal:
WebSearch[input]: This tool allows users to search for information on the internet. It is useful for finding websites that may contain answers to the user's questions. The function does not directly provide answers; it returns a list of sites that might.
TextExtractor[input]: This tool extracts text from a webpage. Input is a URL and output is plain text content of the page.
LinkFinder[input]: Extracts links from plain text and produces a plain text response with newline-separated links.
AIAnswerer[input]: An AI model capable of answering questions based on an input passage of text. The input must be a text question referencing a #E[n] variable, e.g., "What is the capital of France, given #E1?"

The input to each function should be a simple string without quotes or "+" to concatenate a string with an evidence variable, e.g., AIAnswerer[Who won the 2019 World Series, given #E2?]

Ensure only one evidence output per plan step.

Output format should be as follows:
Plan: [first action based on input question]
#E0 = [function to call with input parameter]
Plan: [next action based on result of #E0]
#E1 = [next function to call and input parameter, possibly including reference to previous evidence, e.g., "Given context #E0"]
...
Final Answer: #E[n], where n is the final evidence number

Question: Who was the first person to reach the summit of Mount Everest and what challenges did they face?


Instruction:
A chat. Create a step-by-step plan to answer the following user query, using any of the available tools. Each plan should be followed by an evidence value which will be the output of one of the functions given an input string that can be the user question, previous evidence values or both.

Available Tools:
Bing[input]: A tool that allows users to search for information on Bing. This tool is useful in finding a list of sites that may contain the answer to the user's question.
TextExtractor[input]: Extracts text from websites provided as newline delimited links. The input is one or more links and produces plain text output containing the content of the links.
LinkFinder[input]: Extracts links from plain text and produces a plain text, newline delimited response of links.
QAModel[input]: Question answering model, particularly useful in answering questions based on an input passage of text. The input must be a text question that references an :evidence[n]: variable.

The function inputs are just plain strings without quotes or "+" to concatenate a string with an evidence variable.

Output Format:
Plan: [first action]
:evidence0: = [function call with input parameter]
Plan: [next action based on result of :evidence0:]
:evidence1: = [next function call and input parameter, referencing previous evidence if necessary]
...
Answer: [:evidence[n]: containing the final answer.]

Question: Who won the Nobel Prize in Literature in 2020 and what is their most famous work?


Instruction:
A chat. Construct a detailed execution plan utilizing the below mentioned tools. Remember to assign the output of each tool to a unique variable #E[index].

Available Tools:
YahooSearch[input]: Fetches search results related to the query from Yahoo search engine.
WebScraper[input]: Scrapes the webpage(s) provided as input and returns the text content.
LinkHarvester[input]: Extracts all the hyperlinks present in the input text.
BOB[input]: An AI model capable of answering questions when provided with a context.

Output Format:
Plan: [First Action]
#E1 = [Tool name with input]
Plan: [Subsequent actions based on prior results]
#E2 = [Next tool name with input possibly referencing prior evidences]
...
Final Answer: #E[n]

Question: What is the history behind the Eiffel Tower and how was it constructed?


Instruction:
A chat. Generate an execution plan to answer the user's question by utilizing the tools at hand. Store the output of each tool in a variable :evidence[n]:

Tools available:
Bing[input]: A tool that enables the user to perform a Bing search. Input is a search string.
WebScraper[input]: Loads websites from the input string containing newline-delimited links. Produces plain text output containing the content of the links.
LinkFinder[input]: Finds links within plain text and returns them as a newline-delimited list.
AIModel[input]: An AI model capable of answering questions based on an input passage of text.

Output format:
Plan: [action based on input question]
:evidence0: = [tool to call with input]
Plan: [next action, based on result of :evidence0:]
:evidence1: = [next tool to call with input, possibly referencing prior evidence]
...
Answer: [:evidence[n]: containing final answer.]

Question: Who won the Nobel Prize in Literature in 2020 and what was their notable work?


Instruction:
A chat. Please create a step-by-step plan to generate an ideal response to the user instruction, making use of a set of available tools. Each plan will have a corresponding evidence value, which will be the output of one of the available functions given an input string that can be the user question, one or more previous evidence values, or a mixture of both.

Here are the tools available to be called:
WebSearch[input]: Tool that allows the user to search for information using a general web search engine. This tool is useful in finding an appropriate list of sites that may or may not include the answer to the user's question.
DataExtractor[input]: Extracts structured data from unstructured text. The function takes as input a piece of text and outputs structured data related to the query.
InfoQA[input]: Question answering tool particularly useful in answering questions based on an input passage of text. The input must be a text question that references a :data[n]: variable.
NewsAPI[input]: Retrieves news articles relevant to the input query. It provides a list of links to news articles.

The output should be in format:
Plan: [first action to take based in input question]
:data0: = [function to call with input parameter]
Plan: [next action to take, based on result of :data0:]
:data1: = [next function to call and input parameter, which may include reference to previous evidence]
...
Answer: [:data[n]: containing the final answer.]

Question: What are some recent scientific breakthroughs in the field of quantum computing?


Instruction:
A chat. Generate a step-by-step plan to answer the following user query using the tools provided. Each tool should be used at least once and each plan must have an associated evidence value, which will be the output of one of the available functions given an input string that can be the user question, one or more previous evidence values, or a mixture of both.

Available Tools:
Bing[input]: A tool that allows the user to search for information on Bing. This tool is useful in finding a list of sites that may contain the answer to the user's question.
PageLoader[input]: Load one or more websites from the input string containing newline delimited links, where input is one or more links, and produces plain text output containing the content of the links.
URLExtractor[input]: Extracts URLs from plain text and produces a plain text, newline delimited response of URLs.
SAM[input]: A language model designed to answer questions based on an input passage of text. The input must be a text question that references an :evidence[n]: variable, e.g. What color is the cat, given :evidence1:?

The output format should be as follows:
Plan: [first action]
:evidence0: = [function with input parameter]
Plan: [next action]
:evidence1: = [next function with input parameter]
...
Answer: [:evidence[n]:]

Question: Who won the Nobel Prize in Literature in 2019 and what are some of their most popular works?


Instruction:
A chat. Construct a plan to describe the structure of DNA.

Tools available:
BioInfoSearch[input]: Searches for biological information related to the input.
StructureSketcher[input]: Sketches structures based on the input context.
InDepthQA[input]: Gives in-depth answers to questions based on the input.
ScientificDataCollector[input]: Collects scientific data related to the input.
SummaryCreator[input]: Creates a summary based on the input context.

Output format:
Plan: Initial step
#Data1 = Function with input parameter
Plan: Next step
#Data2 = Next function with input parameter
...
Final Description: #Data[n]


Instruction:
A chat. Provide a systematic plan to answer the following question utilizing the resources at your disposal. Each step should involve one of the available tools, and the output of each tool should be stored in a variable #E[index] for future reference.

Available Tools:
GoogleScholar[input]: A tool that searches academic papers and scholarly articles. The input should be a research topic or query, and the output will be a list of relevant academic sources.
PDFExtractor[input]: A tool that extracts text from a PDF file. The input should be a link to a PDF file, and the output will be the full text of the PDF.
NLP[input]: A natural language processing tool that can understand and answer questions based on a given context. The input should be a question and some context, and the output will be an answer to the question.

Format:
Plan: [First Action]
#E1 = [Tool with Input Parameter]
Plan: [Next Action]
#E2 = [Next Tool with Input Parameter]
...
Final Answer: #E[n]

Question: What is the latest research on the effects of climate change on polar bear populations?


Instruction:
A chat. Develop a strategy to respond to the following query using the available resources. For each stage in your strategy, specify which external tool you would use along with the corresponding input. Store the outcome into an evidence variable (#E[index]) that can be referenced later.

Tools Available:
DuckDuckGo[input]: A tool that lets users perform searches using DuckDuckGo. This tool provides a list of sites that might contain the answer to the user's question.
SiteScraper[input]: Loads one or more websites from the input string (containing newline delimited links), producing plain text output containing the content of the pages.
URLExtractor[input]: Extracts URLs from plain text and produces a plain text, newline-delimited response of URLs.
QAModel[input]: A language model capable of answering questions based on an input passage of text. The input must be a text question that references an :evidence[n]: variable, e.g., "What color is the cat, given :evidence1:?"

The output format should be as follows:
Plan: [first action]
:evidence0: = [function to call with input parameter]
Plan: [next action, based on result of :evidence0:]
:evidence1: = [next function to call and input parameter, which may include reference to previous evidence, e.g., "Given context :evidence0"]
...
Answer: [:evidence[n]: containing the final answer.]

Question: Who won the Nobel Prize in Physics in 2020 and what was their contribution?


Instruction:
A chat. Please provide a detailed plan to solve the following problem, using the tools provided. For each step of your plan, specify which tool you will use and what input you will give it. You can store the output from each tool in a variable :E[index] that can be used as input for subsequent steps.

Here are the tools available:

SearchEngine[input]: This tool allows you to search the internet for information on any topic. The input should be a string containing the query. The output is a list of links that may contain relevant information.
TextExtractor[input]: This tool extracts all text content from a given URL. The input should be a single URL, and the output is a plain text version of the webpage's content.
QA[input]: This tool can answer questions based on general knowledge or given context. The input should be a question, optionally followed by "Given context: :E[n]" where n is the index of a previous evidence.
ImageFinder[input]: This tool finds images related to a given input. The input should be a string describing what you're looking for, and the output is a link to an image.
Translate[input]: This tool translates a given text into English. The input should be a string in any language, and the output is the translated text in English.

The output should follow this format:
Plan: [description of the first action]
:E1 = [tool to call with input parameter]
Plan: [description of the next action, based on the result of :E1]
:E2 = [next tool to call with input parameter, possibly referencing previous evidence like ":E1"]
...
Final Answer: :En

Question: What is the significance of Mona Lisa painting and who painted it? Also find an image of the painting.


Instruction:
A chat. Please generate a step-by-step plan to answer the following question using the available tools. Each tool will produce an evidence value, which is the output of one or more functions given an input string that can be either the user's query, previous evidence values, or both.

Here are the tools you can use:
SearchEngine[input]: This tool allows users to search for information on the internet. It doesn't directly provide answers but offers a list of websites that might contain the needed information.
WebScraper[input]: This tool extracts plain text from one or more websites provided in the input string (links separated by newline).
LinkExtractor[input]: This tool pulls out links from any given plain text and provides a plain text response with newline-separated links.
QAEngine[input]: A tool capable of answering questions based on common knowledge as well as specific context derived from prior evidence. The input should be a question that may reference an :evidence[n]: variable.

The function inputs must be plain strings without quotes or "+" to concatenate a string with an evidence variable, e.g., QAEngine[What is the capital of France, given :evidence1:?]

Remember to include only one evidence output per plan step.

Output format:
Plan: [first action based on input question]
:evidence0: = [function call with input parameter]
Plan: [next action based on result of :evidence0:]
:evidence1: = [next function call and input parameter, potentially referencing previous evidence like "Given context :evidence0"]
...
Answer: [:evidence[n]: containing the final answer.]

Question: What is the population of Tokyo and what are some popular tourist attractions there?


Instruction:
A chat. Develop a plan to respond to the following inquiry using the provided tools. Each stage of the plan should have a corresponding piece of evidence, which is the output of one of the available functions. This could be the user's question, prior evidence, or a combination of both.

These are the tools you can use:
YahooSearch[input]: This tool lets the user search for information via Yahoo. It returns a list of sites that might contain the answer to the user's question.
SiteReader[input]: This tool loads one or more websites from an input string (containing newline-separated links), producing plain text output with the contents of those links.
LinkCollector[input]: This tool extracts links from plain text, returning a plain text, newline-separated list of links.
AIQA[input]: An AI-powered question-answering tool that responds to queries based on an input text passage. The input must be a text question that refers to an :evidence[n]: variable, such as "What is the lifespan of a turtle, given :evidence1:?"

Each function's input should be a simple string, without quotation marks or "+" to combine a string with an evidence variable, like AIQA[What is the lifespan of a goldfish, given :evidence3:?]

Only one piece of evidence should be included per plan step.

The output should look like this:
Plan: [first action based on input question]
:evidence0: = [function to call with input parameter]
Plan: [next action based on result of :evidence0:]
:evidence1: = [next function to call and input parameter, which may include reference to previous evidence, e.g., "Given context :evidence0"]
...
Answer: [:evidence[n]: containing the final answer.]

Question: What is the process of photosynthesis and why is it important for life on Earth?


Instruction:
A chat. Please create a step-by-step plan to generate an optimal response to the user instruction, making use of a set of available tools. Each plan will have a corresponding evidence value, which will be the output of one of the available functions given an input string that can be the user question, one or more previous evidence values, or a combination of both.

Here are the tools available to be called:
WebSearch[input]: Tool that allows the user to search for information using a general web search engine. This tool is useful in finding a list of sites that may contain the answer to the user's query.
ContentScraper[input]: Load one or more websites from the input string containing newline delimited links, where input is one or more links, and produces plain text output containing the content of the links.
LinkExtractor[input]: Extracts links from plain text and produces a plain text, newline delimited response of links.
QAModel[input]: Question answering language model, particularly useful in answering questions based on an input passage of text. The input must be a text question that references an :evidence[n]: variable, e.g. What color is the cat, given :evidence1:?

The output should be in format:
Plan: [first action to take based in input question]
:evidence0: = [function to call with input parameter]
Plan: [next action to take, based on result of :evidence0:]
:evidence1: = [next function to call and input parameter, which may include reference to previous evidence, e.g. "Given context :evidence0"]
...
Answer: [:evidence[n]: containing the final answer.]

Question: Who won the Nobel Prize in Physics in 2020 and what was their contribution?


Instruction:
A chat. Create a plan to answer the following question using the tools provided. Each step in your plan should be followed by an evidence value that corresponds to the output of one of the available functions given an input string, which can be the user's query, previous evidence values, or both.

Here are the tools you have at your disposal:
WebSearch[input]: A tool that allows the user to search for information on the internet. The function does not directly provide answers but gives a list of websites that may contain the required information.
TextExtractor[input]: Extracts text from web pages based on a newline delimited list of links as input and produces plain text content of these links.
LinkFilter[input]: Filters out irrelevant links from a newline delimited list of links and provides a more focused list of links.
AskJeeves[input]: A tool that answers questions based on general knowledge or context provided. The input must be a question that references an :evidence[n]: variable, e.g., What is the population of Paris, given :evidence1:?

The input to each function should be a simple string without quotes or "+" to concatenate a string with an evidence variable, e.g., AskJeeves[What is the capital of France, given :evidence2:?]

Each plan step should only include one evidence output.

The output format should be as follows:
Plan: [first action to take based on the input question]
:evidence0: = [function to call with input parameter]
Plan: [next action to take, based on result of :evidence0:]
:evidence1: = [next function to call and input parameter, which may reference previous evidence, e.g., "Given context :evidence0"]
...
Answer: [:evidence[n]: containing the final answer.]

Question: Who won the 2020 Nobel Prize in Physics and what was their contribution to science?


Instruction:
A chat. Devise a consecutive plan to meet the user mandate, harnessing the presented array of tools. Each plan will correlate with an evidence value, which is the output of one of the specified functions when furnished an input string that could be the user's question, former evidence values, or a blend of both.

Presented tools:
InfoSeek[input]: Tool allowing the user to delve for information via InfoSeek search engine. This tool is advantageous in discovering a spectrum of sites that may harbor the answer to the user's question.
WebExtractor[input]: Seizes one or more websites from the input string embodying newline-broken links. The input is one or more links, culminating in plain text output enveloping the content of the links.
LinkSnatcher[input]: Nabs links from plain text, delivering a plain text, newline-separated directory of links.
QAProcessor[input]: Question-answering language model, notably proficient in addressing questions premised on an input text passage. The input has to be a text-based question that denotes an :evidence[n]: variable.

Output format:
Plan: [Outset action cemented in input question]
:evidence0: = [Function to initiate with input parameter]
Plan: [Subsequent action reliant on result of :evidence0:]
:evidence1: = [Successive function to initiate and input parameter, likely signifying prior evidence, e.g., "Pertaining to :evidence0:"]
...
Finalized Response: [:evidence[n]: owning the conclusive answer]

Question: Who painted the artwork 'Starry Night' and what other artworks have they created?


Instruction:
A chat. Create a step-by-step plan to answer the following question using the tools provided. For each step, indicate which tool will be used and what input it will receive. You can store the results of each tool in a variable #E[index] that can be referred to in later steps.

The available tools are:
WebSearch[input]: A tool that performs an internet search based on the given input.
ReadArticle[input]: A tool that reads an online article from a given URL and provides a summary of its content.
QA[input]: A tool that answers questions based on general knowledge or specific context provided as part of the input.
ExtractLinks[input]: A tool that extracts all URLs from a given text.

Output format:
Plan: [first action]
#E1 = [function with input]
Plan: [next action]
#E2 = [function with input]
...
Final Answer: #E[n]

Question: What is the tallest building in New York City and when was it built?


Instruction:
A chat. Please create a step-by-step plan to generate an ideal response to the user instruction, making use of a set of available tools. Each plan will have a corresponding evidence value, which will be the output of one of the available functions given an input string that can be the user question, one or more previous evidence values, or a mixture of both.

Here are the tools available to be called:
WebSearch[input]: Tool that allows the user to search for information using a web search engine. This tool is useful in finding an appropriate list of sites that may include the answer to the user's question.
TextExtractor[input]: Extracts plain text from a website URL provided as input and produces a plain text output containing the content of the link.
QAEngine[input]: A powerful question answering tool that uses AI to provide direct answers to questions based on general world knowledge or specific context provided.
LinkPicker[input]: Picks the most relevant links from a list of URLs provided as input.
InfoProcessor[input]: Processes a passage of text and extracts key pieces of information related to a specific query.

The output should be in format:
Plan: [first action to take based in input question]
#E1 = [function to call with input parameter]
Plan: [next action to take, based on result of #E1]
#E2 = [next function to call and input parameter, which may include reference to previous evidence]
...
Final Answer: #E[n]

Question: What is the history of the Eiffel Tower and what materials were used in its construction?


Instruction:
A chat. Create a plan to answer the following question using the tools provided. Each step of your plan should be accompanied by an evidence variable that captures the output of the tool used in that step.

Here are the available tools:
1. WebSearch[input]: This tool allows you to perform a web search with any given input string. The results can be a list of websites or articles that may contain the answer to your query.
2. TextExtractor[input]: This tool extracts plain text from one or more URLs provided as newline-separated strings in the input.
3. LinkCollector[input]: This tool collects all the links present in a given piece of text and outputs them as newline-separated strings.
4. QAModel[input]: This is a question-answering model that can provide answers based on a given context. The input must be a question that references an :evidence[n]: variable, e.g., "What is the capital of France, given :evidence1:?"

The output format should be as follows:
Plan: [first action]
:evidence0: = [function to call with input parameter]
Plan: [next action based on result of :evidence0:]
:evidence1: = [next function to call with input parameter, which may include reference to previous evidence]
...
Answer: [:evidence[n]: containing the final answer]

Question: What is the most populated city in Canada and what is its main industry?


Instruction:
A chat. Please provide a step-by-step plan to answer the user's question using the following tools. Each step in your plan should correspond to an evidence value, which will be the output of one of the available functions given an input string that can be the user question, previous evidence values, or both.

Here are the tools you have at your disposal:
Bing[input]: This tool allows users to search for information using the Bing search engine. It is useful for finding a list of sites that may contain the answer to the user's question.
WebScraper[input]: This tool loads one or more websites from the input string containing newline delimited links and produces plain text output containing the content of the links.
LinkExtractor[input]: This tool extracts links from plain text and produces a plain text, newline delimited response of links.
QAModel[input]: A language model designed to answer questions based on an input passage of text. The input must be a text question that references an :evidence[n]: variable.

The output format should be as follows:
Plan: [first action to take based on the input question]
:evidence0: = [function to call with input parameter]
Plan: [next action to take, based on result of :evidence0:]
:evidence1: = [next function to call and input parameter, which may include reference to previous evidence]
...
Answer: [:evidence[n]: containing the final answer.]

Question: What are some popular tourist attractions in Paris and what is their historical significance?


Instruction:
A chat. Please create a step-by-step plan to generate an ideal response to the user instruction, making use of a set of available tools. Each plan will have a corresponding evidence value, which will be the output of one of the available functions given an input string that can be the user question, one or more previous evidence values, or a mixture of both.

Here are the tools available to be called:
SearchEngine[input]: Tool that allows the user to search for information using a general search engine. This tool is useful in finding appropriate sites that may include the answer to the user's question.
WebScraper[input]: Load one or more websites from the input string containing newline delimited links, where input is one or more links, and produces plain text output containing the content of the links.
LinkExtractor[input]: Extract links from plain text and produces a plain text, newline delimited response of links.
QAModel[input]: Question answering model, particularly useful in answering questions based on an input passage of text. The input must be a text question that references an :evidence[n]: variable.

The output should be in format:
Plan: [first action to take based in input question]
:evidence0: = [function to call with input parameter]
Plan: [next action to take, based on result of :evidence0:]
:evidence1: = [next function to call and input parameter, which may include reference to previous evidence]
...
Answer: [:evidence[n]: containing the final answer.]

Question: What is the population of New York City and what languages are most commonly spoken there?


Instruction:
A chat. Please generate a plan to answer the user's question using the tools provided. Each step in the plan should have corresponding evidence produced by one of the tools. The evidence is represented as :evidence[n]:

Tools Available:
DuckDuckGo[input]: A tool that performs a search using DuckDuckGo search engine.
Readability[input]: A tool that summarizes the main points from a long piece of text.
LLM[input]: A language model that can answer questions when given a passage of text as context.
LinkCollector[input]: A tool that collects all the links from a given piece of text.

Output Format:
Plan: [Description of the first action]
:evidence0: = [First function call with input]
Plan: [Description of the second action]
:evidence1: = [Second function call with input]
...
Answer: [:evidence[n]: containing the final answer.]

Question: Who won the 2020 Nobel Prize in Literature?


Instruction:
A chat. Create a systematic plan to solve the following problem. You can make use of any of the tools listed below. For each step in your plan, indicate the tool you would use and the input you would give it. Store the output of each tool in a variable #E[index].

Available Tools:
GoogleSearch[input]: Searches Google for the input query and returns a list of potential sources.
ReadPage[input]: Reads the full text of a webpage specified by the input URL.
AskJeeves[input]: A tool that answers questions based on general knowledge and specific context provided as input.
ExtractLinks[input]: Takes a block of text as input and extracts any URLs contained within.

Output Format:
Plan: [Description of the first step]
#E1 = [Tool used and its input]
Plan: [Description of the next step, possibly referencing the output of the previous step]
#E2 = [Next tool and its input]
...
Final Answer: #En

Question: How did the invention of the steam engine impact industrialization?


Instruction:
A chat. For the following task, create a step-by-step plan to generate an ideal response using the available tools. Each plan will have a corresponding evidence value, which will be the output of one of the available functions given an input string.

Here are the tools available to be called:
GoogleMaps[input]: Tool that allows the user to search for geographical information and distances between locations.
Wikipedia[input]: Tool that allows the user to search for factual information from Wikipedia.
QA[input]: Tool that can answer questions either directly from common sense and general world knowledge or answering questions given input context that may contain the answer.
WeatherAPI[input]: Tool that provides weather forecasts for specific locations.
FlightTracker[input]: Tool that provides real-time flight status and tracking.

Question: What is the distance between London and Paris, what's the current weather in both cities, and are there any flights delayed between these two cities?


Instruction:
A chat. Create a step-by-step plan to solve the following problem using these available tools. Each tool can be called with an input string and will produce output that can be stored in a variable #E[index] for use in subsequent steps.

Available Tools:
1. WebSearch[input]: This tool performs a web search based on the input string and returns a list of relevant websites.
2. TextScraper[input]: This tool extracts all text from a given website URL, which is provided as the input string.
3. QA[input]: This tool answers questions based on common knowledge or given context. The input should be a question, optionally followed by "Given context: #E[n]" where n refers to the index of previously obtained evidence.
4. PatentDatabase[input]: This tool searches a database of patents based on the input string and returns relevant patent information.
5. WikiLookup[input]: This tool retrieves information from Wikipedia based on the input string.

The output format should be:
Plan: [first action]
#E1 = [function call with input parameter]
Plan: [next action based on result of #E1]
#E2 = [next function call with input parameter]
...
Final answer: #E[n]

Question: Who invented the steam engine and what were some of their notable inventions?


Instruction:
A chat. Create a sequential plan to respond to the following user query utilizing the provided tools. Each plan should correspond to an evidence value, which would be the output of a function given an input string.

Available tools:
DuckDuckGo[input]: A tool that enables users to perform internet searches via DuckDuckGo.
URLExtractor[input]: This tool extracts URLs from any given plaintext input.
WebReader[input]: This tool reads and converts webpage contents into plaintext from a given URL.
KnowledgeEngine[input]: A language model designed to answer questions based on context provided as input. It requires a question referencing an :Evidence[n]: variable.

Output Format:
Plan: [Initial course of action]
:Evidence0: = [Function to execute with its input]
Plan: [Subsequent course of action]
:Evidence1: = [Next function to execute with its input, possibly referring to prior Evidence]
…
Final Answer: [:Evidence[n]: Containing the ultimate answer]

Question: Who wrote the book "To Kill a Mockingbird" and what other works did they author?


Instruction:
A chat. Create a sequential plan to address the user query using the below-mentioned tools. Each step will result in an evidence variable that could be referenced in subsequent steps.

Tools Available:
DuckDuckGo[input]: Search tool using DuckDuckGo search engine. It doesn't provide direct answers but lists potential sites having the required information.
URLReader[input]: Reads one or multiple websites from the input string containing newline separated links. Input is one or more links and it outputs plain text content of those links.
HyperlinkExtractor[input]: Extracts hyperlinks from plain text and returns them in a newline-separated manner.
NLPAnswerer[input]: Natural Language Processing model capable of answering queries based on an input text passage.

Output Format:
Plan: [Initial Action]
:Evidence0: = [Function Call with Parameter]
Plan: [Next Step Based on :Evidence0:]
:Evidence1: = [Subsequent Function Call with Parameter, might refer back to previous Evidence]
...
Answer: [:EvidenceN:, which contains the final answer.]

Question: Who was the architect behind the design of Sydney Opera House and what other significant buildings did they design?


Instruction:
A chat. Please create a step-by-step plan to generate an optimal response to the user query, making use of the following available tools. Each plan will have a corresponding evidence value which is the output of one of the available functions given an input string that can be the user question, one or more previous evidence values, or a combination of both.

Here are the tools available to be called:
Bing[input]: Tool that allows the user to search for information using the Bing search engine. This tool is useful in finding an appropriate list of sites that may or may not include the answer to the user's question.
WebScraper[input]: Load one or more websites from the input string containing newline delimited links, where input is one or more links, and produces plain text output containing the content of the links.
LinkExtractor[input]: Extract links from plain text and produces a plain text, newline delimited response of links.
QAEngine[input]: Question answering language model, particularly useful in answering questions based on an input passage of text. The input must be a text question that references an :evidence[n]: variable.

The output should be in format:
Plan: [first action to take based in input question]
:evidence0: = [function to call with input parameter]
Plan: [next action to take, based on result of :evidence0:]
:evidence1: = [next function to call and input parameter, which may include reference to previous evidence]
...
Answer: [:evidence[n]: containing the final answer.]

Question: What are some major accomplishments of Albert Einstein?


Instruction:
A chat. For the following task, generate a step-by-step plan to solve it. The tools available are:
GoogleSearch[input]: This tool allows you to search for information using Google.
Wikipedia[input]: This tool lets you find information from Wikipedia.
QA[input]: A tool that can answer questions based on common sense and general world knowledge.
Scraper[input]: Load one or more websites from the input string containing newline delimited links.
LinkExtractor[input]: Extracts links from plain text.

Question: What is the historical significance of the Colosseum in Rome?


Instruction:
A chat. Generate a step-by-step plan to address the following question using the available tools. Each stage of your plan should correspond to an evidence value, which represents the output of one of the available functions given an input string that might be the user question, one or more prior evidence values, or a mix of both.

Tools at your disposal:
YahooSearch[input]: Allows users to search for information using Yahoo's search engine. Useful for locating a range of sites that may contain the answer to the user's question.
HyperlinkGatherer[input]: Extracts hyperlinks from plain text and returns them as a plain text, newline-separated list of links.
WebsiteParser[input]: Retrieves the content of one or more websites from an input string containing newline-separated links.
InfoModel[input]: A language model capable of answering questions based on a supplied passage of text. The input must be a textual question referencing an :evidence[n]: variable.

The output should follow this format:
Plan: [Initial action based on the input question]
:evidence0: = [Function to call with input parameter]
Plan: [Subsequent action based on the outcome of :evidence0:]
:evidence1: = [Next function to call and input parameter, possibly referring to earlier evidence]
...
Answer: [:evidence[n]: Contains the final answer]

Question: What are the main ingredients used in making traditional Italian lasagna?


Instruction:
A chat. Please develop a plan to answer the following question using the tools provided. For each step in your plan, indicate which tool you will use and what input you will provide to that tool. You can store the output of each tool into a variable #E[index] for reference in later steps.

Here are the available tools:
SearchEngine[input]: A tool that allows the user to search for information on the internet. The input should be a query string related to the information needed.
ArticleReader[input]: This tool reads articles from the given URL(s) and provides the text content as output.
LinkExtractor[input]: Extracts links from plain text and produces a plain text, newline delimited response of links.
QA[input]: Tool that can answer questions either directly from common sense and general world knowledge, or answering questions given input context that may contain the answer.

The output format should be:
Plan: [first action to take based on input question]
#E1 = [function to call with input parameter]
Plan: [next action to take, based on result of #E1]
#E2 = [next function to call and input parameter, which may include reference to previous evidence, e.g. "Given context #E1"]
...
Final answer: #E[n]

Question: What is the history of the Eiffel Tower and who designed it?


Instruction:
A chat. Create a plan to solve the user's question using the provided tools. For each step, specify the tool used and its input, storing the result in an evidence variable.

Tools Available:
WikiLookup[input]: Searches Wikipedia for information related to the input query.
FactChecker[input]: Verifies factual claims by cross-referencing multiple sources. Input should be a claim to verify.
QAModel[input]: Answers questions using common sense, world knowledge, or given context. The input should be a question, possibly referencing previous evidence.
ImageSearch[input]: Finds images related to the input query.

Output Format:
Plan: [first action]
:Evidence0: = [tool with input]
Plan: [next action]
:Evidence1: = [tool with input, possibly referencing :Evidence0:]
...
Answer: [:EvidenceN:]

Question: Who was the first person to climb Mount Everest and are there any pictures of him during the expedition?


Instruction:
A chat. Create a step-by-step plan to find out the average lifespan of an African elephant in the wild.

Here are the tools available:
- Encyclopedia[input]: A tool that allows you to search for information from a large online encyclopedia.
- QA[input]: Tool that can answer questions either directly from common sense and general world knowledge, as well as answering questions given input context that may contain the answer.
- AnimalDatabase[input]: A specialized database containing detailed information about various animal species.
- FactChecker[input]: Validates the accuracy of a statement or piece of information.
- DataComparer[input1, input2]: Compares two pieces of data and determines which one is more accurate.

The output should be in format:
Plan: first action to take based on input question
#E1 = function to call with input parameter
Plan: next action to take, based on result of #E1
#E2 = next function to call and input parameter, which may include reference to previous evidence, e.g. "Given context #E1"
...
Final answer: #E[n]


Instruction:
A chat. Please create a step-by-step plan to generate an optimal response to the user instruction, making use of a set of available tools. Each plan will have a corresponding evidence value, which will be the output of one of the available functions given an input string that can be the user question, one or more previous evidence values, or a combination of both.

Here are the tools available to be called:
Bing[input]: Tool that allows the user to search for information using the Bing search engine. This tool is useful in finding an appropriate list of sites that may include the answer to the user's query.
TextExtractor[input]: Extracts plain text from websites provided as input and produces a plain text output containing the content of the links.
URLFinder[input]: Extracts URLs from plain text and produces a plain text, newline separated response of URLs.
AnswerBot[input]: Question answering bot, particularly useful in answering questions based on an input passage of text. The input must be a text question that references an :evidence[n]: variable, e.g. What color is the dog, given :evidence1:?

The output should be in format:
Plan: [first action to take based in input question]
:evidence0: = [function to call with input parameter]
Plan: [next action to take, based on result of :evidence0:]
:evidence1: = [next function to call and input parameter, which may include reference to previous evidence, e.g. "Given context :evidence0"]
...
Answer: [:evidence[n]: containing the final answer.]

Question: Who was the first person to climb Mount Everest without supplemental oxygen and what were their reasons for doing so?


Instruction:
A chat. Please develop a step-by-step plan to generate an appropriate response to the user instruction, utilizing the set of available tools. Each plan will have a corresponding evidence value, which will be the output of one of the available functions given an input string that could be the user question, one or more previous evidence values, or a mixture of both.

Available tools are:
DuckDuckGo[input]: Allows the user to search for information using DuckDuckGo's search engine. Useful for locating a list of sites that might contain the answer to the user's question.
SiteLoader[input]: Loads one or more websites from the input string containing newline-delimited links. Input is one or more links, producing plain text output containing the link contents.
UrlExtractor[input]: Extracts URLs from plain text, providing a plain text, newline-separated response of URLs.
InfoGenie[input]: Question-answering language model, particularly adept at answering questions based on an input passage of text. The input must be a text question referencing a :fact[n]: variable, e.g., What color is the cat, given :fact1:?

Output format:
Plan: [First action based on input question]
:fact0: = [Function to call with input parameter]
Plan: [Next action based on result of :fact0:]
:fact1: = [Next function to call and input parameter, which may include reference to previous fact, e.g., "Given context :fact0"]
...
Answer: [:fact[n]: Containing the final answer.]

Question: Who won the Nobel Prize in Literature in 2020 and what are their most acclaimed works?


Instruction:
A chat. Please construct a methodical plan to address the following question, utilizing the resources listed. Each phase of your plan should yield an evidence value, which represents the output of one of the available functions after being provided an input string that can either be the user's inquiry, earlier evidence values, or both.

You have access to the following tools:

1. NetSearch[input]: This tool enables users to look up information through a widely-used search engine. It aids in locating various sites that might contain the answer to the user's question. The function doesn't provide a direct answer; instead, it identifies possible sources of the answer.
2. PageParser[input]: This tool pulls plain text from one or more websites designated by the input string containing newline separated links. The input comprises one or more URLs, and the output is plain text encapsulating the contents of the linked pages.
3. HyperlinkHarvester[input]: This tool extracts hyperlinks from plain text and returns a plain text, newline-separated array of links.
4. FactoidAI[input]: This is a language model built to answer queries based on a given piece of text. The input needs to be a text-based question that refers to a #E[n] variable, for example, "How tall is the Eiffel Tower, given #E1?"

The input to each function should simply be a string without quotes or "+" to concatenate a string with an evidence variable, for instance, FactoidAI[Who wrote War and Peace, given #E2?]

Make sure to include only one evidence output per plan step.

The output should adhere to the following structure:
Plan: [first action based on input question]
#E0 = [function to call with input parameter]
Plan: [next action based on result of #E0]
#E1 = [next function to call and input parameter, which may refer to previous evidence, e.g., "Given context #E0"]
...
Final Answer: #E[n]

Question: Who was Galileo Galilei and what were his major contributions to science?


Instruction:
A chat. Create a step-by-step plan to solve the user's query using the following tools. Each tool must be used in one or more steps of your plan, and each step should have an associated evidence value.

Here are the available tools:
Bing[input]: This function allows you to search for information using Bing. It can find relevant websites that may contain the answer to the question.
TextScraper[input]: This tool extracts text from the given website links. The input is a string containing newline-separated URLs.
LinkExtractor[input]: This tool extracts all the links present in the plain text provided as input.
GPT3[input]: A language model that answers questions based on an input passage of text. The input must be a text question referencing an :evidence[n]: variable, e.g., "What color is the cat, given :evidence1:?"

The output format should be:
Plan: [first action]
:evidence0: = [function call with input parameter]
Plan: [next action based on result of :evidence0:]
:evidence1: = [next function call with input parameter, which might reference previous evidence]
...
Answer: [:evidence[n]: containing the final answer.]

Question: What is the history of the Eiffel Tower and what were some controversies surrounding its construction?


Instruction:
A chat. Please create a plan to generate an ideal response to the user instruction, making use of a set of available tools. Each plan will have a corresponding evidence value, which will be the output of one of the available functions given an input string that can be the user question, one or more previous evidence values, or a mixture of both.

Here are the tools available to be called:
GoogleSearch[input]: Tool that allows the user to search for information using Google. This tool is useful in finding appropriate sites that may include the answer to the user's question.
WebScraper[input]: Load one or more websites from the input string containing newline delimited links, where input is one or more links, and produces plain text output containing the content of the links.
LinkExtractor[input]: Extract links from plain text and produces a plain text, newline delimited response of links.
LMQA[input]: Language model question answering tool, particularly useful in answering questions based on an input passage of text. The input must be a text question that references an :evidence[n]: variable, e.g. What color is the cat, given :evidence1:?

The output should be in format:
Plan: [first action to take based in input question]
:evidence0: = [function to call with input parameter]
Plan: [next action to take, based on result of :evidence0:]
:evidence1: = [next function to call and input parameter, which may include reference to previous evidence, e.g. "Given context :evidence0"]
...
Answer: [:evidence[n]: containing the final answer.]

Question: Who won the Nobel Prize in Physics in 2020 and what was their contribution?


Instruction:
A chat. Please provide a step-by-step plan to answer the user's question using the available tools. Each step should have an associated evidence value, which will be the output of one of the functions given an input string that can be the user's question, previous evidence values, or both.

Here are the tools you can use:
SearchEngine[input]: A tool that allows users to search for information on the internet. This function is useful in finding a list of websites that may contain the answer to the user's query.
ContentExtractor[input]: Extracts text content from a website URL provided as input and produces plain text output containing the content of the link.
LinkFinder[input]: Extracts links from plain text and produces a plain text response of newline-separated links.
AnswerBot[input]: A language model designed to answer questions based on an input passage of text. The input must be a text question referencing a #E[n] variable, e.g., "What is the capital of France, given #E1?"

The input to each function should be a plain string without quotes or "+" to concatenate a string with an evidence variable, e.g., AnswerBot[What is the population of New York City, given #E3?]

Each plan step should include only one evidence output.

The output format should be:
Plan: [first action based on input question]
#E0 = [function to call with input parameter]
Plan: [next action based on result of #E0]
#E1 = [next function to call and input parameter, including reference to previous evidence if necessary, e.g., "Given context #E0"]
...
Final Answer: #E[n]

Question: What is the history of the Eiffel Tower and who were its main architects?


Instruction:
A chat. Create a step-by-step plan to answer the following user query using the available tools. Each tool can be used multiple times but should not be used consecutively and each plan must have an associated evidence value.

Here are the tools that can be called:

WebSearch[input]: A tool that allows users to search for information on the internet. This tool is useful in finding relevant websites or pages that may contain the answer to the user's question.
TextAnalyzer[input]: Analyzes a given text and provides a summary of its content. The input should be a string containing the text to analyze.
QAEngine[input]: Can answer questions based on common sense, general world knowledge, and specific context provided as input.
LinkCollector[input]: Extracts all links from a given text. The input should be a string containing the text with links.
SiteReader[input]: Reads the content of one or more websites from the input string which contains newline delimited links.

The output format should be:
Plan: [first action]
#Evidence1 = [function call with input parameter]
Plan: [next action based on #Evidence1]
#Evidence2 = [next function call with input parameter, referencing previous evidence if necessary]
...
Final Answer: #Evidence[n]

Question: Who invented the first electric car and when was it invented?


Instruction:
A chat. Design a stepwise strategy to respond to the user's inquiry using the tools provided. Each step should correspond to an evidence value, which is the product of a function given its input.

Tools at Disposal:
AskJeeves[input]: A tool that utilizes Ask Jeeves search engine to amass information associated with the input query.
WebsiteLoader[input]: Takes multiple websites from the input string comprising newline separated links and yields plain text content of these links.
LinkPicker[input]: Picks out links from plain text and renders them as newline separated strings.
SmartAnswer[input]: An AI-driven question-answering tool that needs a question referencing an :evidence[n]: variable.

Output Format:
Plan: [First move based on input question]
:evidence0: = [Function to invoke with input parameters]
Plan: [Following move based on the effect of :evidence0:]
:evidence1: = [Upcoming function to summon with input parameters potentially citing prior evidence]
...
Final Answer: :evidence[n]:

Question: Who invented the telephone and where were they born?


Instruction:
A chat. Please generate a plan to answer the following question using the tools provided. Each step of your plan should correspond with an evidence variable, which will be the output of one of the available functions given an input string that can be the user's query, previous evidence values, or both.

Here are the tools you have at your disposal:
1. Bing[input]: This tool allows the user to search for information using the Bing search engine. It is useful in finding a list of sites that may contain the answer to the user's question.
2. TextParser[input]: This tool extracts key pieces of information from a block of text and produces a plain text response containing this information.
3. LinkCollector[input]: This tool extracts links from plain text and provides a newline delimited list of these links.
4. KnowledgeModel[input]: A language model capable of answering questions based on an input passage of text. The input must be a text question referencing an :evidence[n]: variable.

The function inputs should be plain strings without quotes or "+" to concatenate a string with an evidence variable, e.g., KnowledgeModel[What is the capital of France, given :evidence1:?]

Ensure each plan step includes only one evidence output.

The output format should be as follows:
Plan: [first action based on input question]
:evidence0: = [function to call with input parameter]
Plan: [next action based on result of :evidence0:]
:evidence1: = [next function to call and input parameter, which may include reference to previous evidence, e.g., "Given context :evidence0"]
...
Answer: [:evidence[n]: containing the final answer.]

Question: Who won the Nobel Prize in Literature in 2020 and what is their most famous work?


Instruction:
A chat. Develop a detailed plan to respond to the following user query, making use of the provided tools. For each step in your plan, provide an associated piece of evidence, which would be the output of a specific function given its input. Inputs could be either the user's original question, previously generated evidence, or a mix of both.

These are the tools you can use:
DuckDuckGo[input]: A tool that enables users to conduct searches via DuckDuckGo. It returns a list of potential sites that might contain answers but does not provide direct answers itself.
SiteLoader[input]: Takes one or more URLs (separated by newlines) as input and outputs the plaintext contents of those sites.
URLExtractor[input]: Extracts URLs from plaintext and provides them as newline-separated plaintext.
KnowledgeModel[input]: A language model capable of answering questions when provided with a text passage as context. The input must be a question referencing an :evidence[n]: variable, such as "What is the height of Mount Everest, given :evidence1:?"

Inputs to these functions should be simple strings without quotation marks or '+' signs for concatenating strings with evidence variables. For instance, KnowledgeModel[What is the capital of France, given :evidence2:?].

Ensure there's only one piece of evidence per plan step.

Output format should be:
Plan: [Initial action based on input question]
:evidence0: = [Function to call with input parameter]
Plan: [Subsequent action based on outcome of :evidence0:]
:evidence1: = [Next function to call with input parameter, potentially referencing prior evidence like "Given context :evidence0"]
...
Final Answer: [:evidence[n]: contains the ultimate answer.]

Question: What is the history behind the Eiffel Tower and why was it built?


Instruction:
A chat. Please create a step-by-step plan to generate an ideal response to the user instruction, making use of a set of available tools.  Each plan will have a corresponding evidence value, which will be the output of one of the available functions given an input string
 that can be the user question, one or more previous evidence values, or a mixture of both.

Here are the tools available to be called:
YahooSearch[input]: Tool that allows the user to search for information using the Yahoo search engine.
InfoExtractor[input]: Extracts key details from a block of text, such as names, dates, locations etc.
SiteLoader[input]: Loads one or more websites from the input string containing newline delimited links, where input is one or more links, and produces plain text output containing the content of the links.
URLFinder[input]: Finds URLs within a body of text and outputs them as a list.
AnswerBot[input]: Answers questions based on an input passage of text. The input must be a text question that references an :evidence[n]: variable.

The output should be in format:
Plan: [first action to take based in input question]
:evidence0: = [function to call with input parameter]
Plan: [next action to take, based on result of :evidence0:]
:evidence1: = [next function to call and input parameter, which may include reference to previous evidence]
...
Answer: [:evidence[n]: containing the final answer.]

Question: What is the history of Microsoft Corporation and who were its founders?


Instruction:
A chat. Please generate a detailed plan to solve the following problem, using the provided tools. Each step in your plan should produce an evidence value.

Tools Available:
DuckDuckGo[input]: A function that uses the DuckDuckGo search engine to retrieve potentially relevant information.
ParseHTML[input]: Takes a list of URLs (newline-separated) and returns the full HTML content of those pages as plain text.
ExtractLinks[input]: Given some text, this function extracts any URLs present in the text.
AskJeeves[input]: A question-answering AI model that takes a question and context as input and provides an answer.

Output Format:
Plan: [description of first step]
#E1 = [tool used and its input]
Plan: [description of next step]
...
Final Answer: #En

Question: Who won the 2018 FIFA World Cup and where was it held?


Instruction:
A chat. Please create a step-by-step plan to generate an ideal response to the user instruction, making use of a set of available tools.

Here are the tools available to be called:
DuckDuckGo[input]: A tool that allows the user to search for information using the DuckDuckGo search engine.
URLScraper[input]: Loads one or more websites from the input string containing newline delimited links, and produces plain text output containing the content of the links.
HyperlinkExtractor[input]: Extracts hyperlinks from plain text and produces a plain text, newline delimited response of links.
QAModel[input]: A question-answering language model that answers questions based on an input passage of text. The input must be a text question that references a #E[index] variable.

The output should be in format:
Plan: [first action to take based in input question]
#E1 = [function to call with input parameter]
Plan: [next action to take, based on result of #E1]
#E2 = [next function to call and input parameter, which may include reference to previous evidence]
...
Final Answer: #E[n]

Question: Who invented the internet and what was their motivation?


Instruction:
A chat. Create a detailed plan to answer the user's question using the tools provided below. For each step in your plan, store the outcome in a variable #E[index].

Available Tools:
WikiSearch[input]: Searches Wikipedia for information based on the input string.
PageReader[input]: Reads the entire page of a given URL and outputs the text.
QAExpert[input]: Answers questions using general world knowledge or specific context provided.

Output Format:
Plan: [First Action]
#E1 = [Function Call with Input]
Plan: [Next Action Based on Result of #E1]
#E2 = [Next Function Call with Input Possibly Referencing Previous Evidence]
...
Final Answer: #E[n]

Question: Who was the first person to climb Mount Everest without supplemental oxygen and when did this happen?


Instruction:
A chat. Create a step-by-step execution plan to solve the following problem using the provided tools. Each step should correspond to an evidence value, which will be the output of a specific function given an input string. This string could be the user's query, a previous evidence value, or a combination of both.

Here are the tools you can use:
DuckDuckGo[input]: A tool that lets users search for information via the DuckDuckGo search engine. It helps locate a range of sites that might contain the answer to the user's question.
SiteReader[input]: Loads one or more websites from an input string (containing newline-separated links). Input is one or more links, and it outputs plain text content from these links.
URLExtractor[input]: Extracts URLs from plain text and provides a plain text, newline-separated list of URLs.
InfoQA[input]: A question-answering language model that answers queries based on an input text passage. The input should be a text-based question referencing an :evidence[n]: variable.

Output should follow this format:
Plan: [First action based on the input question]
:evidence0: = [Function to call with input parameter]
Plan: [Next action, based on the outcome of :evidence0:]
:evidence1: = [Next function to call with input parameter, possibly referring to previous evidence]
...
Final Answer: [:evidence[n]: containing the final answer]

Question: Who won the Nobel Prize in Literature in 2019 and what was their most famous work?


Instruction:
A chat. Develop a systematic approach to respond to the user inquiry utilizing the following resources. Each resource must be utilized at least once and every plan should correspond to an evidence variable.

Tools available:

DuckDuckGo[input]: Allows users to find information via DuckDuckGo. Useful for identifying potential sources containing the answer.
SiteReader[input]: Loads content from one or more websites supplied in the input string (links separated by newlines). Outputs the plain text content of these sites.
URLCollector[input]: Extracts URLs from plain text and provides them as newline-separated strings.
AnswerBot[input]: Can answer questions using common sense, world knowledge, or given context. The input should be a question that may refer to prior evidence variables.

Output Format:
Plan: [Initial Action]
#Evidence1 = [Call to function with input parameter]
Plan: [Subsequent action depending on #Evidence1]
#Evidence2 = [Following function call with input parameters possibly referring to #Evidence1]
...
Final Response: #Evidence[n]

Question: What is the tallest mountain in Australia and how was it formed?


Instruction:
A chat. Generate a plan to solve the following problem using the specified tools. For each step of the plan, indicate the corresponding evidence variable.

Tools Available:
DuckDuckGo[input]: Search engine tool for general queries.
SiteScraper[input]: Tool that retrieves content from specific websites given a link.
LinkPicker[input]: Tool that selects pertinent links from a set of URLs.
FactFinder[input]: Question-answering tool that uses a knowledge base to provide answers based on input context.

Output Format:
Plan: [First action based on the input question]
#E1 = [Function to call with input parameters]
Plan: [Next action based on #E1's outcome]
#E2 = [Next function to call with input parameters (may refer to prior evidence)]
...
Final Answer: #En

Question: What is the population of New York City and when was it founded?


Instruction:
A chat. Create a sequential plan to generate an optimal response to the user instruction, making use of a set of available tools. Each plan will correspond to an evidence value, which will be the output of one of the available functions given an input string that can be the user question, one or more previous evidence values, or a mixture of both.

Here are the tools available to be called:
DuckDuckGo[input]: Tool that allows the user to search for information using the DuckDuckGo search engine. This tool is helpful in finding a list of sites that may or may not contain the answer to the user's question. The function does not directly answer the question; instead, it finds a list of sites that may have the answer.
SiteLoader[input]: Loads one or more websites from the input string containing newline-delimited links, where input is one or more links, and produces plain text output containing the content of the links.
LinkFinder[input]: Extracts links from plain text and produces a plain text, newline-delimited response of links.
AIQA[input]: Artificial Intelligence Question Answering model, particularly useful in answering questions based on an input passage of text. The input must be a text question that references an :evidence[n]: variable, e.g. What color is the dog, given :evidence1:?

The output should be in format:
Plan: [first action to take based in input question]
:evidence0: = [function to call with input parameter]
Plan: [next action to take, based on result of :evidence0:]
:evidence1: = [next function to call and input parameter, which may include reference to previous evidence, e.g. "Given context :evidence0"]
...
Answer: [:evidence[n]: containing the final answer.]

Question: What is the population of Tokyo and how has it changed over the last decade?


Instruction:
A chat. Construct a solution strategy for the problem below utilizing the tools listed. For each plan, indicate the associated evidence variable resulting from the execution of a tool.

Here are the tools available to be called:
WikiSearch[input]: Tool that enables users to search Wikipedia for information.
PageParser[input]: Parses a webpage and extracts the main body of text.
QAHelper[input]: Provides answers to questions using either general world knowledge or specific context provided.
HyperlinkCollector[input]: Collects hyperlinks from a given piece of text.

Output should adhere to the following structure:
Plan: [first action to take based on input question]
#Evidence1 = [function to call with input parameter]
Plan: [next action to take, based on result of #Evidence1]
#Evidence2 = [next function to call and input parameter, which may include reference to previous evidence]
...
Final Answer: #Evidence[n]

Question: Who won the Nobel Prize in Literature in 2020 and what is their most famous work?


Instruction:
A chat. For the following tasks, make plans that can solve the problem step-by-step. For each plan, indicate which external tool together with tool input to retrieve evidence. You can store the evidence into a variable #E[index] that can be called by later tools.

Here are the tools available to be called:
Encyclopedia[input]: Tool that allows the user to search for information from Encyclopedia. This tool is particularly useful in gaining knowledge about people, places, companies, historical events, and other types of factual information. The input to this function should be a search string that would help find the appropriate page. The output may be quite verbose and noisy, but often contains the correct piece of information related to the input query.
AIQA[input]: Tool that can answer questions either directly from common sense and general world knowledge, as well as answering questions given input context that may contain the answer.

Each plan should be followed by exactly one evidence (#E[index]) value.

The output should be in format:
Plan: [first action to take based in input question]
#E1 = [function to call with input parameter]
Plan: [next action to take, based on result of #E1]
#E2 = [next function to call and input parameter, which may include reference to previous evidence, e.g. "Given context #E1"]
...
Final answer: #E[n]

Question: What is the population of the city where Microsoft headquarters is located?


Instruction:
A chat. Develop a sequential plan to address the following query. Indicate the specific tool to be utilized at each stage, along with the necessary inputs. Store any obtained evidence in a variable #E[index], which can be recalled in subsequent steps.

Tools Available:
GoogleScholar[input]: This tool facilitates academic searches on Google Scholar. The input should be a keyword or phrase related to the desired topic.
TextAnalyzer[input]: This tool analyzes a block of text and answers questions based on the analysis.

Output Structure:
Plan: [Initial course of action]
#E1 = [First tool to use with its respective input]
Plan: [Subsequent action, dependent on the outcome of #E1]
#E2 = [Following tool to employ with its input, potentially referring back to prior evidence]
...
Final Answer: #E[n]

Question: What are the primary causes of climate change according to recent scientific studies?


Instruction:
A chat. Create a step-by-step plan to solve the following user instruction using the available tools. Each plan will have an associated evidence value, which is the output of one of the functions given an input string that can be the user question, previous evidence values, or both.

Here are the tools available to be called:
Bing[input]: Tool that allows the user to search for information using the Bing search engine. This tool is useful in finding relevant sites that may contain the answer to the user's question.
URLParser[input]: Extracts URLs from plain text and produces a list of URLs.
WebReader[input]: Loads one or more websites from the input string containing newline delimited links, where input is one or more links, and produces plain text output containing the content of the links.
Querier[input]: Question answering model, particularly useful in answering questions based on an input passage of text. The input must be a text question that references an #E[n] variable, e.g. What color is the dog, given #E1?

The input to each function should just be a plain string, without quotes or "+" to concatenate a string with an evidence variable, e.g. Querier[What is the capital of France, given #E3?]

Be sure to only include one evidence output per plan step.

The output should be in format:
Plan: [first action to take based in input question]
#E0 = [function to call with input parameter]
Plan: [next action to take, based on result of #E0]
#E1 = [next function to call and input parameter, which may include reference to previous evidence, e.g. "Given context #E0"]
...
Answer: [#E[n] containing the final answer.]

Question: Who is the current president of Microsoft and what major projects have they overseen?


Instruction:
A chat. Please create a step-by-step plan to generate an ideal response to the user instruction, making use of a set of available tools.  Each plan will have a corresponding evidence value, which will be the output of one of the available functions given an input string
 that can be the user question, one or more previous evidence values, or a mixture of both.

Here are the tools available to be called:
GoogleSearch[input]: Tool that allows the user to search for information using the Google search engine.
WebsiteLoader[input]: Loads one or more websites from the input string containing newline delimited links, where input is one or more links, and produces plain text output containing the content of the links.
LinkFinder[input]: Extract links from plain text and produces a plain text, newline delimited response of links.
KnowledgeModel[input]: Question answering language model, particularly useful in answering questions based on an input passage of text.

Be sure to only include one evidence output per plan step.

The output should be in format:
Plan: [first action to take based in input question]
#E1 = [function to call with input parameter]
Plan: [next action to take, based on result of #E1]
#E2 = [next function to call and input parameter, which may include reference to previous evidence]
...
Final answer: #E[n]

Question: Who was Albert Einstein and what were his main contributions to science?


Instruction:
A chat. Develop a sequence of steps to answer the user's query utilizing the tools provided. Every step should have a corresponding evidence value, which would be the output of a function given its input.

Available Tools:
YahooSearch[input]: A tool that employs Yahoo Search engine to collect information pertaining to the input query.
SiteReader[input]: Loads several websites from the input string consisting of newline separated links and provides plain text content of these links.
HyperlinkExtractor[input]: Extracts hyperlinks from plain text and presents them as newline separated strings.
IntelligentQA[input]: An AI-powered question-answering tool that requires a question referencing an :evidence[n]: variable.

Output Format:
Plan: [Initial step based on input question]
:evidence0: = [Function to call with input parameters]
Plan: [Subsequent step based on the outcome of :evidence0:]
:evidence1: = [Next function to call with input parameters possibly referring to previous evidence]
...
Final Answer: :evidence[n]:

Question: What is the tallest building in New York City and when was it completed?


Instruction:
A chat. Formulate a detailed plan to respond to the user's inquiry utilizing the available tools. Each tool should be employed at least once, and every plan stage should correspond to an evidence value.

Tools Available:
GoogleSearch[input]: Allows the user to conduct a Google search based on the input string.
PageReader[input]: Reads and extracts the textual content from a webpage.
HyperlinkFinder[input]: Finds hyperlinks within a body of text.
QuerySolver[input]: Solves queries based on a provided piece of text.

Output Format:
Plan: [Initial action based on the input question]
#E1 = [Function to execute with its parameters]
Plan: [Subsequent action based on the outcome of #E1]
#E2 = [Following function to execute with its parameters]
...
Final Answer: #E[last]

Question: What is the significance of the Rosetta Stone in understanding ancient Egyptian hieroglyphics?


Instruction:
A chat. Create a plan to respond to the user instruction below, making use of the set of available tools. Each plan will have a corresponding evidence value, which will be the output of one of the available functions given an input string.

Here are the tools available to be called:
WebSearch[input]: Tool that enables users to search for information online.
TextExtractor[input]: Load one or more websites from the input string containing newline delimited links, where input is one or more links, and produces plain text output containing the content of the links.
HyperlinkExtractor[input]: Extract links from plain text and produces a plain text, newline delimited response of links.
KnowledgeEngine[input]: Language model that answers questions based on an input passage of text.  The input must be a text question that references an :evidence[n]: variable.

Output format:
Plan: [first action to take based in input question]
:evidence0: = [function to call with input parameter]
Plan: [next action to take, based on result of :evidence0:]
:evidence1: = [next function to call and input parameter, which may include reference to previous evidence]
...
Final Answer: [:evidence[n]: containing the final answer.]

Question: Who won the Nobel Prize in Literature in 2018 and what was their most famous work?


Instruction:
A chat. Formulate a plan to address the user's request below using the available tools. Each plan will generate an evidence variable, which is the output of a specific tool given an input string.

Available tools:
DuckDuckGo[input]: Tool that allows users to search for information using DuckDuckGo search engine.
WebReader[input]: Reads the content of web pages given their URLs.
URLSelector[input]: Selects relevant URLs from a list of URLs.
InfoGenie[input]: A question-answering model capable of generating answers based on general knowledge or given context.

Output format:
Plan: [initial action based on input question]
$Evidence1 = [tool to call with input parameters]
Plan: [subsequent action based on $Evidence1]
$Evidence2 = [next tool to call with input parameters, possibly referencing $Evidence1]
...
Answer: [$EvidenceN containing final answer]

Question: What is the history of Bitcoin and who invented it?


Instruction:
A chat. Develop a detailed plan to respond to the user's instruction using the provided tools. Each plan should correspond to an evidence value, which will be the output of a function given a certain input string. This could be the user's question, one or more previous evidence values, or a combination of both.

These are the tools at your disposal:
BingSearch[input]: Allows the user to search for information using Bing. It does not provide direct answers but generates a list of sites that might contain the required information.
URLLoader[input]: Loads one or more websites from an input string containing newline separated links. The input is one or more links, and the output is plain text containing the contents of the links.
HyperlinkHarvester[input]: Extracts hyperlinks from plain text and provides a plain text, newline-separated response of links.
AIQA[input]: An AI-based question-answering model that excels at answering queries based on an input text passage. The input must be a textual question referencing an :evidence[n]: variable.

The output should adhere to the following structure:
Plan: [First action based on the input question]
:evidence0: = [Function to invoke with input parameter]
Plan: [Subsequent action based on the outcome of :evidence0:]
:evidence1: = [Next function to invoke and input parameter, possibly referring to prior evidence]
...
Final Answer: [:evidence[n]: that contains the ultimate answer]

Question: Who won the Nobel Prize in Literature in 2019 and what was their most acclaimed work?


Instruction:
A chat. Formulate a plan to answer the question: "When was the last solar eclipse visible from New York City?"

Here are the tools available:
AstroEvents[input]: Tool that provides information about astronomical events.
QA[input]: Tool that can answer questions either directly from common sense and general world knowledge, as well as answering questions given input context that may contain the answer.
DateFinder[input]: Finds dates associated with specific events.
EventTracker[input]: Tracks past events based on a provided context.
LLM[input]: Question answering language model.

The output should be in format:
Plan: first action to take based in input question
#E1 = function to call with input parameter
Plan: next action to take, based on result of #E1
#E2 = next function to call and input parameter, which may include reference to previous evidence, e.g. "Given context #E1"
...
Final answer: #E[n]


Instruction:
A chat. Create a step-by-step plan to generate an ideal response to the user instruction, using the following available tools. Each plan will have a corresponding evidence value, which will be the output of one of the available functions given an input string that can be the user question, one or more previous evidence values, or a mixture of both.

Here are the tools available to be called:
Bing[input]: Tool that allows the user to search for information using the Bing search engine. This tool is useful in finding a list of sites that may contain the answer to the user's question.
WebReader[input]: Load one or more websites from the input string containing newline delimited links, where input is one or more links, and produces plain text output containing the content of the links.
LinkPicker[input]: Extracts links from plain text and produces a plain text, newline delimited response of links.
AIM[input]: An artificial intelligence model capable of answering questions based on an input passage of text. The input must be a text question that references a #E[n] variable, e.g. What color is the cat, given #E1?

The output should be in format:
Plan: [first action to take based in input question]
#E0 = [function to call with input parameter]
Plan: [next action to take, based on result of #E0]
#E1 = [next function to call and input parameter, which may include reference to previous evidence, e.g. "Given context #E0"]
...
Answer: [#E[n] containing the final answer.]

Question: Who won the Nobel Prize in Literature in 2020 and what was their most famous work?