Assistant

Get your own dedicated AI team to handle administrative tasks, follow-ups, and daily operations while you focus on growth. With expert human oversight, you'll have an AI-powered executive team at a fraction of the cost.

AI Dream Team

Run JavaScript

Run general-purpose JavaScript in Toolbox. Recommended for document generation, image processing, archives, and file creation. Choose the runtime whose listed libraries best support the task. Prefer available libraries over reimplementing their functionality. Runtime recommendations are not restrictions. Always try to reuse an existing session_id for related work. If the response says sessions are unavailable, each call starts fresh; include all required inputs in every call. Save reusable values in SESSION_STATE; ordinary const and let variables are local to each call. Responses list saved variables and loaded libraries. Select libraries with the libraries parameter: papaparse (Papa) for CSV/TSV, xlsx (XLSX) for spreadsheets, lodash (_) for data transformations, jszip (JSZip) for ZIP archives, pdf-lib (PDFLib) for creating/editing PDFs, docx (docx) for Word documents, pptxgenjs (PptxGenJS) for creating presentations, jimp (Jimp) for raster images, and ffmpeg for audio/video processing. Selected libraries remain loaded in the session. Omit libraries or pass [] when no additional libraries are needed. Use the selected globals directly; no imports or package installation are needed. This is a browser sandbox: use in-memory bytes and export through output.file, not filesystem or download helpers. Keep Papa worker and download options disabled and check parse errors. pdf-lib cannot extract text or render PDFs; standard PDF fonts have limited character support. pptxgenjs cannot import existing presentations. Jimp uses the v1 API: fromBuffer(bytes), resize({ w, h }), crop({ x, y, w, h }), and new Jimp({ width, height, color }). Use getBuffer for image export; avoid filesystem paths, URL loading, and font downloads. Use browser Canvas for text drawing and SVG/WebP decoding. Selecting ffmpeg provides an already-loaded ffmpeg instance; do not call load() or terminate(). Write inputs with await ffmpeg.writeFile("input.mp4", new Uint8Array(await files[0].arrayBuffer())). Run await ffmpeg.exec(["-i", "input.mp4", "output.mp3"], 60000); check the returned exit code is 0, then export await ffmpeg.readFile("output.mp3") through output.file. For ffmpeg.ffprobe, write JSON metadata to a file with -o and validate that file; this build may return -1 even on success. FFmpeg and its virtual files persist in the session; delete unneeded files with await ffmpeg.deleteFile(name). Prefer short clips and small files; transcoding is CPU- and memory-intensive. All FFmpeg assets are bundled, so local-file processing works without network access. Selected attachments are available in the files array as File objects, in the requested order, each with an additional id property. Read UTF-8 text with await files[0].text(), binary bytes with await files[0].arrayBuffer(), or raster images with await createImageBitmap(files[0]). For SVG, use new Image() with an image/svg+xml Blob URL created inside the sandbox, await image.decode(), and draw the image onto a canvas; do not pass an SVG Blob to createImageBitmap. Include the SVG namespace and explicit width/height in SVG markup. Revoke the Blob URL after drawing. Export PNG with await canvas.convertToBlob({ type: "image/png" }) on an OffscreenCanvas. When network access is disabled, only blob: and data: image sources are allowed. Return a value to produce text output; objects and arrays are serialized as JSON. Create chat attachments with output.file({ filename, data, mimeType }); data accepts a string, Blob, File, ArrayBuffer, or typed array. Use a filename without paths. mimeType is optional and defaults to text/plain for strings, the Blob type when available, or application/octet-stream. Call output.file multiple times to create multiple files; you can also return text in the same run. Network access is disabled by default and controlled by the Toolbox setting.

toolbox_run_js

Run Python

Run general-purpose Python in Toolbox. Recommended for data processing and analytics, including dataset cleaning, aggregation, statistics, and numerical calculations. Choose the runtime whose listed libraries best support the task. Prefer available libraries over reimplementing their functionality. Runtime recommendations are not restrictions. New sessions provide the Python standard library. Import its modules normally. Load third-party dependencies through the required packages parameter before code runs. Available packages: numpy for numerical arrays, pandas for tabular data analysis, matplotlib and seaborn for static charts, plotly and bokeh for interactive HTML charts, pillow for images, openpyxl for Excel workbooks, pypdf2 for reading and editing PDFs, python-docx for Word documents, requests for HTTP requests, beautifulsoup4 for HTML parsing (from bs4 import BeautifulSoup), jinja2 for text/HTML templates, and jsonschema for JSON validation. Dependencies load automatically, including NumPy, pandas, Matplotlib, and Pillow where required. Write packages before code. For import pandas as pd, include "pandas" unless the session response already lists it as loaded. Use packages: [] for standard-library-only code or when all required packages are already loaded in the session. Then import the selected packages in code; loading a package does not create an import alias. If an available package raises ModuleNotFoundError, retry in the same session with that package included in packages. Other third-party packages and pip installation are unavailable. For Matplotlib or seaborn charts, call matplotlib.use("Agg") before importing matplotlib.pyplot as plt or seaborn, and save figures to io.BytesIO. Pass the buffer's getvalue() to output.file with a filename and MIME type; close figures with plt.close(fig). For Plotly, export fig.to_html(include_plotlyjs=True, full_html=True). For Bokeh, use bokeh.embed.file_html with bokeh.resources.INLINE. Export that HTML through output.file with MIME type text/html; avoid show() and CDN resources. Plotly static image export is unavailable. For images, select pillow and import from PIL, for example from PIL import Image. Save images to io.BytesIO with an explicit format, then export its getvalue() through output.file. For pypdf2, import PdfReader and PdfWriter from PyPDF2. For python-docx, import Document from docx. Save Excel, PDF, and Word documents to io.BytesIO and export its getvalue() through output.file. For HTTP, select requests and import requests. Network access must be enabled; browser CORS rules apply. Use a timeout and call response.raise_for_status() before reading the response. For HTML, use BeautifulSoup(markup, "html.parser"). Always try to reuse an existing session_id for related work. If the response says sessions are unavailable, each call starts fresh; include all required inputs in every call. Variables, imports, loaded packages, and virtual files persist in that session. Responses list saved variables and loaded packages. Attachments selected for the current call appear in the files list in the requested order as dictionaries with id, name, type, and path. Their bytes are available in the virtual filesystem at files[0]["path"]. Read text with pathlib.Path(files[0]["path"]).read_text(), bytes with .read_bytes(), or CSV with pd.read_csv(files[0]["path"]). Use print() or a final expression for text output; values use their Python string representation. Create chat attachments with output.file(filename, data, mime_type=None). Data must be a string, bytes, bytearray, or memoryview; filenames must not contain paths. Text defaults to text/plain and bytes to application/octet-stream. For example, output.file("summary.csv", df.to_csv(index=False), "text/csv"). For a file written by a library, read its bytes and pass them to output.file. Call output.file multiple times to create multiple files. Only files passed to output.file become chat attachments. Top-level await is supported, but top-level return is not. Network access is disabled by default and controlled by the Toolbox setting.

toolbox_run_python

Toolbox

Web Search

DALL-E 3

Render

Render an interactive canvas with HTML source to the user interface. For a large or complex canvas, build it in steps. The first call renders a rough working version: the layout and a simple stand-in for each main part, a few hundred lines at most. Make it soon: keep your reasoning before it short, don't plan every detail or draft the code in your reasoning, and render it before testing its code with other tools. Then add the rest with `update_interactive_canvas`, one or a few parts per call, until every part the user asked for is built: don't stop at the rough version. Keep each response, reasoning included, well under your output limit: the limit applies to each response, and every tool call ends one. The HTML source can include JavaScript and CSS to create interactive elements. This can be used to create custom user interfaces, games, demos, charts, and more. The canvas width is always 100% of the container width, and the height can be specified in pixels. Use this for the FIRST render and for full rewrites. For small follow-up tweaks to a canvas you have already rendered, prefer `update_interactive_canvas`. Use search_interactive_canvas_source and read_interactive_canvas_lines to inspect the latest source before editing. Use read_interactive_canvas_source only when you need the full source.

render_interactive_canvas

Update

Apply small, targeted edits to the most recently rendered interactive canvas instead of re-emitting the full HTML. Each edit performs an exact, literal find-and-replace on the current HTML. Use this WHENEVER you only need to tweak parts of an existing canvas you previously rendered with `render_interactive_canvas` — it is much faster and uses far fewer output tokens than re-emitting the entire HTML. Also use it to grow a canvas in steps after a rough first render: add one or a few parts per call, so that each response stays well under your output limit.

Rules:
- Do NOT use this for the very first render — use `render_interactive_canvas` instead.
- Each `oldText` must match EXACTLY ONCE in the current HTML; include enough surrounding context to make it unique. If a match is ambiguous (matches more than once) or missing, the call will fail and you should retry with more context, or fall back to `render_interactive_canvas` with the full updated HTML.
- Edits are applied in order; later edits see the result of earlier ones.
- Prefer many small edits over one big rewrite — it makes failures localised and easier to retry.
- Use search_interactive_canvas_source to locate code, then read_interactive_canvas_lines for the surrounding source before choosing oldText. Line number prefixes in those results are not part of the source.

update_interactive_canvas

Read Source

Read the full, exact HTML source of the latest interactive canvas rendered or updated by this plugin. Does not change the canvas. Attachment placeholders remain unchanged. Prefer search_interactive_canvas_source and read_interactive_canvas_lines when you only need part of a large canvas.

read_interactive_canvas_source

Search Source

Search the latest interactive canvas HTML for a literal keyword, ignoring case. Return matching lines with 1-based line numbers and the total match count. Does not change the canvas. Use read_interactive_canvas_lines to read nearby lines before editing. Line number prefixes are not part of the source.

search_interactive_canvas_source

Read Lines

Read an inclusive range of lines from the latest interactive canvas HTML, with 1-based line numbers. Does not change the canvas. endLine is capped at the final source line. Line number prefixes are not part of the source; omit them when building update_interactive_canvas edits.

read_interactive_canvas_lines

Interactive Canvas

Web Page Reader

Read Web Page (Firecrawl)

Image Search

JavaScript Interpreter

Render HTML

Market News

Render Chart

GPT Image 2.0

Web Search (Serp)

Generate Image Grok

Todo List

Extract Web Page

Research Plan

Use this tool to create and manage a structured task list for your current research session. This helps track progress, organize complex investigations, and demonstrate thoroughness.

### When to Use This Tool

Use proactively for:
1. Complex multi-step research (3+ distinct phases)
2. Non-trivial investigations requiring careful planning
3. User explicitly requests research todo list
4. User provides multiple research topics (numbered/comma-separated)
5. After receiving new research instructions - capture requirements as todos (use merge=false to add new ones)
6. After completing research phases - mark complete with merge=true and add follow-ups
7. When starting new research areas - mark as in_progress (ideally only one at a time)

### When NOT to Use

Skip for:
1. Single, straightforward questions
2. Trivial lookups with no organizational benefit
3. Research completable in < 3 trivial steps
4. Purely conversational/clarification requests
5. Don't add a task to verify findings unless asked, or you'll overfocus on validation

### Examples

<example>
  User: Research the impact of climate change on Arctic wildlife
  Assistant: *Creates todo list:*
  1. Analyze temperature trends in Arctic regions
  2. Identify key Arctic species and habitats
  3. Review scientific studies on wildlife impacts
  4. Synthesize findings and correlations
<reasoning>
  Multi-phase research with dependencies requiring systematic investigation.
</reasoning>
</example>

<example>
  User: Compare healthcare systems across Nordic countries
  Assistant: *Creates todo list with specific items for each country's system, funding models, outcomes, and comparative analysis*

<reasoning>
  Complex comparative research requiring systematic tracking across multiple systems.
</reasoning>
</example>

<example>
  User: Investigate renewable energy adoption, economic impacts, policy frameworks, and future projections.
  Assistant: *Creates todo list breaking down each research area into specific investigation tasks*

<reasoning>
  Multiple complex research areas provided as list requiring organized investigation management.
</reasoning>
</example>

<example>
  User: Research why my company's market share is declining - analyze competitors, market trends, customer feedback.
  Assistant: *Creates todo list: 1) Competitor analysis, 2) Market trend research, 3) Customer sentiment analysis, 4) Internal factor review, 5) Strategic recommendations*

<reasoning>
  Business analysis requires multiple research phases across different data sources.
</reasoning>
</example>

### Examples of When NOT to Use the Todo List

<example>
  User: What's the capital of France?
  Assistant: The capital of France is Paris.

<reasoning>
  Single trivial factual lookup completed in one step.
</reasoning>
</example>

<example>
  User: Explain what photosynthesis is.
  Assistant: Photosynthesis is the process by which plants convert sunlight into energy...

<reasoning>
  Informational request with no complex research investigation needed.
</reasoning>
</example>

<example>
  User: Find the current stock price of Apple.
  Assistant: *Looks up current AAPL price* Apple (AAPL) is currently trading at...

<reasoning>
  Single straightforward data lookup with immediate results.
</reasoning>
</example>

<example>
  User: What does GDP stand for?
  Assistant: GDP stands for Gross Domestic Product...

<reasoning>
  Simple definition request with no multi-step research required.
</reasoning>
</example>

### Task States and Management

1. **Research States:**
  - pending: Not yet started
  - in_progress: Currently investigating
  - completed: Research finished successfully
  - cancelled: No longer needed

2. **Research Management:**
  - Update status in real-time
  - Mark complete IMMEDIATELY after finishing each phase
  - Only ONE research area in_progress at a time
  - Complete current investigations before starting new ones

3. **Research Breakdown:**
  - Create specific, actionable investigation items
  - Break complex research into manageable phases
  - Use clear, descriptive research objectives

When in doubt, use this tool. Proactive research management demonstrates thoroughness and ensures complete investigation of requirements.

update_research_plan

Search Web

Search the web using SERP API (Google search engine) for real-time information about any topic. Use this tool when you need up-to-date information that might not be available in your training data, or when you need to verify current facts. The search results will include relevant snippets and URLs from web pages. This is particularly useful for questions about current events, technology updates, or any topic that requires recent information.

research_tool_search_web

Retrieves the text content of a web page in markdown format. When in Lightweight Mode, this tool returns an extracted content with only the answer based on the extractInstructions. When in Comprehensive Mode, this tool returns the full content of the web page.

extract_web_page

Read Full Web Page

Retrieves the full text content of a web page in markdown format, this will return the full content of the website that may be extremely long.

read_full_web_page_content

Deep Research

Render an interactive web app with HTML/CSS/JS source to the user interface. For a large or complex web app, build it in steps. The first call renders a rough working version: the layout and a simple stand-in for each main part, a few hundred lines at most. Make it soon: keep your reasoning before it short, don't plan every detail or draft the code in your reasoning, and render it before testing its code with other tools. Then add the rest with `update_web_app`, one or a few parts per call, until every part the user asked for is built: don't stop at the rough version. Keep each response, reasoning included, well under your output limit: the limit applies to each response, and every tool call ends one. The HTML source can include JavaScript and CSS to create interactive elements. This can be used to create custom user interfaces, games, demos, charts, simple web apps, and more. Use this plugin when the user asks to create a web app, an interactive demo, a game, or some other types of interactive content. Use this for the FIRST render and for full rewrites. For small follow-up tweaks to a web app you have already rendered, prefer `update_web_app`. Use search_web_app_source and read_web_app_lines to inspect the latest source before editing. Use read_web_app_source only when you need the full source.

render_web_app

Apply small, targeted edits to the most recently rendered web app instead of re-emitting the full HTML. Each edit performs an exact, literal find-and-replace on the current HTML. Use this WHENEVER you only need to tweak parts of an existing web app you previously rendered with `render_web_app` — it is much faster and uses far fewer output tokens than re-emitting the entire HTML. Also use it to grow a web app in steps after a rough first render: add one or a few parts per call, so that each response stays well under your output limit.

Rules:
- Do NOT use this for the very first render — use `render_web_app` instead.
- Each `oldText` must match EXACTLY ONCE in the current HTML; include enough surrounding context to make it unique. If a match is ambiguous (matches more than once) or missing, the call will fail and you should retry with more context, or fall back to `render_web_app` with the full updated HTML.
- Edits are applied in order; later edits see the result of earlier ones.
- Prefer many small edits over one big rewrite — it makes failures localised and easier to retry.
- Use search_web_app_source to locate code, then read_web_app_lines for the surrounding source before choosing oldText. Line number prefixes in those results are not part of the source.

update_web_app

Read the full, exact HTML source of the latest web app rendered or updated by this plugin. Does not change the app. Attachment placeholders remain unchanged. Prefer search_web_app_source and read_web_app_lines when you only need part of a large app.

read_web_app_source

Search the latest web app HTML for a literal keyword, ignoring case. Return matching lines with 1-based line numbers and the total match count. Does not change the app. Use read_web_app_lines to read nearby lines before editing. Line number prefixes are not part of the source.

search_web_app_source

Read an inclusive range of lines from the latest web app HTML, with 1-based line numbers. Does not change the app. endLine is capped at the final source line. Line number prefixes are not part of the source; omit them when building update_web_app edits.

Login to AI Dream Team