Choosing the right AI model in MindStudio is essential to balancing cost, performance, and quality. This guide walks through the key considerations and demonstrates how to use the Profiler tool to compare models directly.

Key Evaluation Criteria

When selecting an AI model, consider the following factors:

1. Price

• Each model has a different cost per token for input (prompt) and output (response).

• Token cost is measured per million tokens (MTOK).

• Tokens roughly equate to words (1 token ≈ 0.75 words).

Cheaper models are suitable for automations and utility tasks. More expensive models often yield better reasoning and generation quality, ideal for final outputs.

2. Latency

• Latency refers to how long the model takes to generate a response.

• Lower-latency models are preferable for interactive or real-time use cases.

3. Output Quality

• Evaluate the coherence, tone, and style of responses.

• Some models produce more creative outputs, while others are better for concise summaries or factual tasks.

• Quality is best assessed by comparing outputs in the Profiler.

4. Context Window

• Determines how much information the model can ingest at once.

• Ranges from 4,000 tokens to over 1,000,000 tokens depending on the model.

• Larger windows are useful for document summarization, legal analysis, or full-site scraping.

Examples:

• GPT-4 Mini: 128K tokens

• Claude 3.5 Haiku: 200K tokens

• Gemini 2.0 Flash: 1M tokens

5. Max Response Size

• Controls how long the model’s output can be.

• Some models are capped at 4,000 tokens while others can produce 8,000–16,000 tokens or more.

• Useful when generating long-form articles, reports, or stories.

Using the Profiler to Compare Models

MindStudio’s Profiler tool lets you test models side by side:

1. Open the Model Settings tab.

2. Click the Profiler button in the top-right corner.

3. Select two or more models for comparison.

4. Standardize settings like temperature and max tokens.

Example Comparison:

• Claude 3.5 Haiku: More expensive, shorter output, faster start.

• GPT-4 Mini: Slightly cheaper, longer and more detailed output.

• Gemini 2.0 Flash: Fastest response, low cost, huge context window.

Workflow Integration

You can open any Generate Text block inside your AI agent and run its prompt through the Profiler to preview output differences across models without altering your workflow.

Summary

To select the best model:

• Use cheaper models for fast, repetitive tasks.

• Choose more capable models for final outputs, reasoning-heavy, or creative tasks.

• Evaluate models across:

  • Cost per token

Choosing the right model ensures your AI agents are both effective and efficient—tailored precisely to your needs.

Writing clear, effective prompts is a foundational skill when building workflows in MindStudio. Whether you're using AI to generate text, images, audio, or video, how you instruct the model makes a significant impact on the result. This guide walks through prompt types, strategies, formatting, and structure.

Understanding Prompt Types

System Prompts

System prompts define the overall role and expectations of the AI agent. They're usually written once per workflow and serve as a blueprint for how the AI should behave.

A good system prompt includes:

• Role of the assistant (e.g., "You are a blog post generator.")

• General responsibilities (e.g., "Research, write, and optimize content.")

• Formatting guidelines (e.g., "Use markdown.")

• Tone/style preferences (e.g., "Professional and concise.")

Use the "Generate Prompt" feature in MindStudio to create a structured draft, and edit it to suit your workflow.

Tip: Use /* */ to add comments in the system prompt that the AI will ignore.

Task Prompts

Task prompts are written inside individual blocks like Generate Text, Generate Image, etc. These should be specific to the action that block is performing.

For example:

Add structure and context with templating or example output to improve quality.

Prompt Writing Techniques

Templating with Tags

Use custom tags like <example_output> to show the AI what the desired output looks like.

Example:

Using Variables

Embed variables using {{ }}:

Markdown Formatting

Markdown lets you structure AI-generated text for easy display in apps or websites.

Common markdown syntax:

• # H1 header

• ## H2 header

• **bold**, *italic*

Markdown is especially useful in display blocks or when instructing the AI to output structured content.

Controlling Tone

Add tone instructions to shape the AI’s voice:

• Professional: formal, structured

• Casual: friendly, conversational

• Spartan: brief, to-the-point

You can mix tones too:

Compare results by previewing the AI's response with and without tone instructions to see the impact.

Creating Structured Outputs (JSON)

For advanced workflows, use structured outputs to extract usable data from AI responses. Switch the output schema to JSON.

Example JSON template:

Now the output can be parsed and reused in other blocks by referencing specific fields.

Summary

Good prompts lead to better AI behavior. Keep these best practices in mind:

• Use system prompts for agent-wide behavior.

• Use task prompts for specific actions.

• Include example outputs and formatting instructions.

• Use variables to make prompts dynamic.

Mastering prompt writing will significantly improve the precision and performance of your AI agents in MindStudio.

This guide introduces key tools and practices for testing and debugging your AI agents as you build them in MindStudio. You’ll also learn how to identify and fix common errors like variable mismatches, high temperature settings, and missing prompts.

Checking the Errors Tab

The first step when building any agent is to check the Errors tab. This will surface:

• Misconfigured blocks

• Referenced variables that don’t exist

• Missing required fields

If the tab shows no errors or warnings, proceed to running your agent using the debugger.

Using the Debugger

The Debugger tracks every step in your agent’s run:

1. Click Preview, then choose Run in Debugger or open a Draft Agent.

2. If your agent includes user input, it will prompt you for a value (e.g., topic = “dogs”).

3. The debugger will log:

   • Each block’s execution

This lets you verify whether the variables are passed correctly and prompts are resolving as expected.

Common Mistake 1: Forgetting to Use the Variable

If an agent runs but doesn’t include user input (e.g., the AI says, “Let me know what you want to write about”), you likely forgot to include the variable in your prompt.

Fix:

• Edit the Generate Text block.

• Use your variable with opening/closing tags:

Re-run the agent and confirm the input is correctly inserted.

Common Mistake 2: Typo in Variable Name

Another common error is referencing a variable that hasn’t been defined—usually due to a typo.

Fix:

• Check the Errors tab.

• Error will indicate something like: Variable 'top' is referenced but does not exist.

• Click the error to highlight the block.

• Correct the variable name to topic

You can test the fix in the debugger using a test value set in the user input configuration.

Common Mistake 3: High Temperature Output

If your AI outputs gibberish or chaotic text, it's likely caused by a temperature setting that is too high.

Fix:

• Go to Model Settings or directly edit the temperature in the Generate Text block.

• Lower the temperature to a mid-range value (recommended default).

• Rerun your test.

MindStudio displays a warning when a temperature setting is too high and may lead to unstable outputs.

Common Mistake 4: Empty Generate Text Block

If the prompt field in a Generate Text block is empty, the Errors tab will show:

Fix:

• Click the error to highlight the block.

• Fill in a prompt like:

Tips for Efficient Debugging

• Use test values for user inputs when debugging without launching a draft.

• Use the debugger expansion panel to trace logic, outputs, and costs.

• Regularly check for spelling errors and missing prompt content.

• Always validate changes with a test run.

Accessing Support and Community Resources

If you run into issues:

• Click Help and Support in the sidebar.

• Access:

  • Support forum

  • Video tutorials

The MindStudio community is active and helpful—many common issues have already been discussed and resolved.

Final Thoughts

Testing and debugging are essential steps in building reliable AI agents. By mastering these basics—especially using the Errors tab and debugger—you’ll streamline your development process and catch problems early.

We show how real AI agents can support partnerships, sales, and business development teams. Led by our Director of Partnerships, Dannielle Sakher, and CEO, Dmitry Shapiro, this practical session explains how to use AI agents that scale your GTM motion, with no costs or setup.

✅ Personalize outreach ✅ Prep for meetings ✅ Surface red flags in deals …and more.

This guide walks through the process of scraping webpage content in MindStudio and using that content in a custom AI agent. The example agent extracts article content from a URL and turns it into a LinkedIn post.

Use Case Overview

We’ll build a URL to LinkedIn Post agent that:

1. Collects a URL from the user.

2. Scrapes the content from that page.

3. Uses AI to generate a LinkedIn post based on the page content.

Step 1: Create a User Input for the URL

1. Add a User Input block to your workflow.

2. Choose the Short Text input type.

3. Name the variable: url

4. Set the label: Enter the URL you'd like to write a LinkedIn post about

Step 2: Scrape the Webpage

1. Add a Scrape URL block.

2. In the URL field, use the variable: {{ url }}

3. Set the output variable name: scraped_content

The block will now extract and store webpage content into the scraped_content variable.

Step 3: Generate AI Output

1. Add a Generate Text block.

2. Write your prompt, including the scraped content:

3. Choose an appropriate model (e.g., Claude 3.5 Haiku).

Step 4: Test the Agent

1. Click Preview and open the draft agent.

2. Try inputting an invalid value (like not a URL) to confirm validation works.

3. Enter a valid URL or use the test value.

4. The AI will:

Recap and Best Practices

• Use the Scrape URL block to pull live content from any webpage.

• Always validate user input when collecting URLs.

• Store scraped data in a clearly named variable for easy reuse.

• Keep the output format as “Text only” for general analysis or “JSON” for structured use cases.

You can further extend this workflow by adding post-processing steps or integration blocks to share or save the generated content.

🚀 Every company is DESPERATE to leverage AI, but they don't know HOW.

That's where YOU come in. 👈

Imagine walking into a business and saying: "I can make your team 3x more productive with AI agents"

Here's what I'm teaching in the Monetizing AI Agents Masterclass:

✅ How to approach companies ✅ Packaging your AI services ✅ Pricing your expertise ✅ Building an AI consulting business ✅ Landing high-paying AI roles (if that's what you want)

No technical background required. Just: • Ability to listen • Ability to observe how customers operate • Ability to translate needs into AI solutions

This isn't the future. This is NOW.

Every industry needs AI efficiency. EVERY. SINGLE. ONE.

Learn how to build powerful AI agents using MindStudio in this comprehensive tutorial. From basic concepts to advanced techniques, this session covers everything you need to get started with building your own AI applications.

Whether you're completely new to AI agent building or looking to level up your skills, this tutorial provides practical examples and best practices you can immediately apply to create powerful AI applications.

No technical skills required -- you will learn everything you need in the class.

AI Agents Covered:

Deep Topic Research: Do hundreds of hours of research and analysis with the click of a button!

Deep People / Entity Research: AI-powered OSINT -- uncover deep insights that can help you understand individuals and organizations.

Get Contact Info: Identify key people mentioned in articles, documents, and web pages, and get their contact info (email, phone, etc).

Fact Checking: Identify inaccuracies, and get the facts!

And over a dozen other AI Agents that can help you get things done and get insights that you've never been able to have before. No mere mortal will be able to compete with you!!!

You Will Also Learn:

🦄 How to easily Customize AI Agents for your specific purposes. 👉 How to easily Build New AI Agents in minutes -- no coding required. 👉 How you can build AI Agents for other people / orgs and make $$$

Welcome to the first lesson in the MindStudio Fundamentals course! This video lays the foundation for everything you’ll be learning in upcoming modules. Whether you're new to AI or just new to MindStudio, this guide will help you understand the core concepts you need to get started building powerful AI agents.

What is MindStudio?

MindStudio is an integrated platform for building and deploying AI agents. It provides:

New to MindStudio? Watch this video...

Anyone can build AI Agents—no experience required. Whether it's your first time or you're just looking for a quick refresher, this video will walk you through the basics of building your first AI Agent with MindStudio.

In just a few minutes, you’ll learn how to launch, customize, and deploy your own intelligent tools—no coding needed.

Navigating the AI Editor

This guide provides a comprehensive overview of the AI Editor interface in MindStudio. You'll learn how to navigate the workspace, configure resources, manage agent settings, and debug workflows efficiently.

Understanding the User Interface

When you create an AI agent, you’re placed inside the AI Editor. The UI is divided into two main sections:

• Left Panel (Explorer): Contains resources like data sources, custom functions, user inputs, and workflows.

• Right Workspace: Displays contextual editing tools and configuration panels based on what you're working on.

Use the explorer to navigate between tabs such as automations, user inputs, and functions. The main workflow typically starts in main.flow, under the automations tab.

Exploring Resources and Workflows

Inside the automations tab:

• The start block initializes the workflow.

• The terminator block ends the workflow.

• You can insert additional logic using the + button to add new blocks.

The canvas supports:

• Vertical and horizontal scrolling (use Shift to scroll horizontally).

• Zooming, reset view (R key), and auto-arranging blocks for a clean layout.

• Quick tools for panning (H key) and selecting (V

Using the Canvas Features

Useful tools in the canvas include:

• Sticky notes for adding comments or reminders.

• Diagnostics tool to validate block linkages and optimize workflows (recommended for advanced users).

• Errors tab to highlight issues such as missing inputs.

• Debugger tab to monitor input/output and cost at each step during agent execution.

Managing Models and Evaluations

Key tabs along the top of the editor:

• System Prompt: Set overall instructions for the agent (e.g., blog post generator). You can also use the Generate Prompt tool to automatically create a structured prompt.

• Model Settings: Choose a default AI model from over 90 options. This acts as a fallback if a block doesn't specify a model.

• Evaluations: Allows you to batch test scenarios (optional for beginners).

Debugging and Diagnostics Tools

Each block has a configurable panel on the right-hand side. For example:

• A Generate Text block lets you enter the prompt.

• A Run Function block switches the configuration panel to support code-based execution.

You can preview your agent and inspect each step’s behavior through the debugger at the bottom.

Final Tips for AI Agent Creation

Select the root agent folder to access:

• General Settings: Name, description, icon, and landing page for sharing.

• Sharing & Access: Set visibility (public/private), enable remixing, and configure API access (business plans only).

• Advanced Settings: Includes onboarding workflows, global variables, and persistent user data (covered in later videos).

• Version History: Revert to previous published versions of your agent.

Summary

Most of your work will happen inside the workflow builder, where you’ll add and configure blocks. This video covers the full UI so you know where to find everything as you start building. If you have questions, check the in-app documentation or leave a comment on the video.

Thanks for watching!

JSON (JavaScript Object Notation) is a powerful and widely used format for storing and exchanging structured data. In MindStudio, understanding how to parse, generate, and utilize JSON is essential for building flexible and powerful AI workflows.

What is JSON?

JSON is a structured data format made up of key-value pairs. Each key is a string (in quotes), and its associated value can be:

• A string ("Alice")

• A number (30)

• A boolean (true)

• An array (["user", "admin"])

• Another object ({"age": 30, "active": true})

JSON also supports nesting, allowing you to build complex hierarchies of data.

JSON Syntax Rules

1. All keys must be strings (in double quotes).

2. Key-value pairs must be comma-separated.

3. Do not include a trailing comma at the end of the last key-value pair.

Using JSON in MindStudio Workflows

Receiving JSON from Blocks

Many blocks, like Search Google News, return data as JSON. This allows you to access structured results, such as article titles, links, and thumbnails.

You can:

• Display the full JSON

• Extract specific values using path expressions

• Iterate through lists using each blocks

Accessing Individual Values

To get a specific value from JSON, use the JSON path:

This extracts the title of the first article from the GoogleNews variable.

Iterating Through Arrays

Use the #each tag to loop through arrays in JSON:

This will render each article's title, link, and thumbnail using Markdown formatting.

Generating JSON with AI

You can use the Generate Text block to ask AI to return structured JSON. For example, extracting all URLs from search results:

Use an output schema to define the format and simplify complex JSON into more usable lists.

Applying JSON in HTML Templates

JSON can also be applied to generate HTML pages dynamically using the Generate Asset block. You can:

• Iterate over content sections

• Conditionally render data like headings, key takeaways, and entities

• Use extracted structured data to build full HTML pages for summaries or reports

Example usage:

• Extract structured information from a Verge article

• Use that data to populate an HTML summary page

• Present it with images, headlines, and lists using embedded JSON paths

Summary

Understanding JSON enables you to:

• Parse and manipulate structured responses

• Extract only the values you need

• Iterate through complex arrays

• Generate clean structured output from unstructured content

Once you master JSON in MindStudio, you'll be able to build significantly more advanced and powerful agents with flexible output formatting and robust data handling.

Integration blocks in MindStudio let your AI agents connect seamlessly to third-party services. These blocks either bring data into your workflow or send data out to external tools, enabling powerful automation use cases.

Overview of Integration Blocks

You can add integration blocks like any other block using the “+” menu and browsing View All Blocks. They appear slightly differently in the editor to visually distinguish them from native blocks.

Integration blocks fall into two categories:

• Input blocks: Pull data into your workflow (e.g. YouTube captions, Google Docs).

• Output blocks: Push data out to external services (e.g. LinkedIn posts, Google Sheets, emails).

Each block has its own configuration panel with parameters specific to the connected service.

Example 1: Automating LinkedIn Posts from YouTube Captions

This workflow extracts captions from a YouTube video and automatically creates and publishes a LinkedIn post summarizing the content.

Blocks Used:

• User Input: Accepts a YouTube URL.

• Fetch YouTube Captions: Retrieves the video transcript.

• Generate Text: Uses AI to summarize the transcript into a LinkedIn post.

• Create LinkedIn Post: Publishes the AI-generated post.

Requires signing into LinkedIn and setting post visibility. AI content is passed using a variable to this block.

This setup automates content repurposing from YouTube into social media.

Example 2: Comparing Financial Reports from Google Docs

This workflow pulls financial text from two Google Docs, extracts numerical data using AI, and formats the comparison into a Google Sheet.

Blocks Used:

• Fetch Google Doc: One block per document (doc1 and doc2).

• Generate Text: Parses both documents, extracts values, and formats as CSV.

• Create Google Sheet: Inserts the CSV into a new sheet.

• Display Content: Displays a link to the generated sheet.

All blocks require signing into your Google account. CSV format enables structured spreadsheet output.

This flow is ideal for automating competitive or financial comparisons.

Example 3: Emailing Daily News Digests from Google News

This workflow searches Google News, extracts top headlines, creates a styled email digest using HTML, and sends it via email.

Blocks Used:

• Google News Search: Queries for a specific keyword (e.g. "AI agents").

• Generate Text: Converts JSON-formatted news into HTML.

• Generate Subject Line: Summarizes the news as a catchy email subject.

• Send Email: Delivers the digest to a recipient using Markdown or HTML.

HTML formatting lets you include images, links, and structure. This is a great use case for daily or weekly digests.

Key Takeaways

• Integration blocks enhance AI workflows by connecting to external tools.

• Data can flow in or out, depending on the block.

• Each service requires setup: You’ll need to sign in to third-party accounts (e.g. Google, LinkedIn).

• Variables pass data between blocks, allowing AI-generated outputs to trigger external actions.

MindStudio supports hundreds of integration blocks, allowing for creative automation across marketing, operations, research, and more.

Use them to transform your agents into powerful, connected tools.

The Evaluations feature in MindStudio allows you to test AI workflows at scale using autogenerated or manually defined test cases. This is especially helpful for validating workflows like moderation filters, where consistent logic must be applied across many inputs.

Why Use Evaluations?

Manually testing workflows via the preview debugger becomes inefficient as the number of test cases grows. Evaluations allow you to:

• Autogenerate test cases with AI

• Specify expected outputs

• Run tests in bulk

• Compare actual vs. expected results

• Use fuzzy matching for flexible validation

Sample Use Case: Spam Detection

In this example, an AI workflow is designed to detect spam comments and flag violations based on defined community guidelines. The workflow takes in a comment via a launch variable and outputs:

• A boolean indicating whether it's spam

• An array of flags indicating types of violations

Creating and Running Test Cases

Step 1: Access the Evaluations Tab

• Navigate to the top-level "Evaluations" tab in your project.

• Click New Test Case to manually add a test or use Autogenerate to let AI create test cases for you.

Step 2: Autogenerate Violating Test Cases

• Input guidance like “generate five test cases that are in violation of our guidelines.”

• AI will produce sample comments with the correct input structure.

• Add expected results (e.g., "is_spam": true, "flags": ["hateful", "off-topic"]).

Step 3: Run Test Cases

• Click Run All to test all cases in parallel.

• MindStudio will show which tests pass or fail based on comparison with expected results.

• Each test can be inspected in the debugger.

Step 4: Autogenerate Non-Violating Test Cases

• Repeat the process with a new prompt: “generate five comments not in violation.”

• Provide expected results (e.g., "is_spam": false, "flags": []).

• Run the new set and verify accuracy.

Matching Methods

MindStudio supports two types of result matching:

• Literal Match: Requires the actual output to exactly match the expected value.

• Fuzzy Match: Allows minor differences or variations in phrasing. Useful for outputs with dynamic AI wording.

Benefits of Evaluations

• Run many test cases at once

• Easily edit and rerun failing cases

• Debug individual results

• Improve the reliability of your AI workflows

Evaluations are a key tool for ensuring your AI behaves as expected at scale. Whether you're building content filters, classifiers, or other deterministic logic, this feature helps you confidently validate your workflows.

What is a Prompt?

A prompt is simply the set of instructions you give an AI. It’s the way you tell the AI what you want — whether that’s an explanation, a summary, a creative draft, a detailed analysis, or anything else you can think of.

The quality of its output depends on the clarity of your request. If you’re vague, you’ll get vague answers. If you’re specific, you’ll get much closer to what you are actually looking for.

Basic Prompting Framework

A simple way to write better prompts is to follow this three-step structure. If you include all three, you’ll almost always get clearer, more useful results.

Context

Context gives the AI the key information it needs in order to follow your instructions. It sets the scene, explains the situation, and helps the AI understand what you’re asking it to do. Without context, the AI has to guess — and its answers will usually be too broad or off-target.

Task

The task is the instruction itself. This is where you tell the AI exactly what you want it to do. The more precise and direct you are, the better the result. Since the AI takes language literally, a well-defined task removes ambiguity and keeps the answer focused on the outcome you actually need.

Format

The format is how you want the response to be delivered. By specifying format, you control the structure and style of the answer, making it easier to read, compare, or use. Without it, the AI decides for you — and that may not align with your goals. Format is what turns a raw answer into something you can apply right away.

Bad vs Good Prompt Examples

Create a Travel Itinerary Prompt

❌ Bad Prompt:

✅ Good Prompt:

Write a Blog Post Prompt

❌ Bad Prompt:

✅ Good Prompt:

MindStudio enables you to schedule AI agents to run automatically at specific times. This is useful for automating repetitive workflows like monitoring web content, generating reports, or triggering notifications without manual input.

Use Case: Website Change Tracker

In this example, we’ll build an AI agent that checks for changes on a website (e.g. OpenAI’s news page) each morning and emails a summary of those changes.

Step 1: Add the “Track Website Changes” AI Module

• Create a new workflow and add the Track Website Changes module.

• In the configuration panel:

  • Enter the target URL (e.g., https://openai.com/blog).

  • Use the default variable names unless you need to customize them.

Step 2: Handle Detected Changes

You’ll configure two outcomes:

• No Changes: Route to an End Workflow block.

• Changes Detected: Route to a Send Email block.

In the Send Email block:

• Connect your email account via the integrations menu (gear icon).

• Set a subject like: Changes Detected on OpenAI News

• Use the {{changes}} variable as the email body to show the summary of detected content updates.

Step 3: Set the Schedule

Click the Start Block, and in the Trigger section on the right:

1. Change the Run Mode from “On Demand” to Scheduled.

2. Click Add to define your schedule.

3. Use natural language or presets like: Every morning at 9:00 AM

4. Set your Time Zone

The agent will now run automatically each morning.

Step 4: Preview & Test

Use the Preview button and run the agent in the Debugger:

• On the first run, it will detect all visible content (no baseline exists yet).

• On subsequent runs, it will only email you if changes are detected.

Summary

Scheduled AI agents are powerful for automating:

• News monitoring

• Report generation

• Notifications

• Daily or weekly workflows

To configure:

1. Use the Track Website Changes module.

2. Send detected changes via Email.

3. Set the schedule from the Start block.

You now have a self-running AI agent that keeps you informed—automatically, every day.

In this deep-dive session, we break down how Deep Research works, how it’s built, and how you can use it to automate competitive analysis, summarize vast sources, generate insights, and more — all with minimal human input.

🚀 What You’ll Learn:

✅ What makes Deep Research a next-gen AI Agent ✅ The architecture behind its autonomous workflow system ✅ How it searches, filters, evaluates, and compiles information ✅ Real demos of Deep Research in action ✅ Tips to build or customize agents like this for your own use cases

In this masterclass led by Dannielle Sakher (Director, Partnerships) and Dmitry Shapiro (CEO), you’ll learn to use these AI Agents that do the content grunt work for you:

✅ Case Study Generator: Turn customer call transcripts into polished success stories ✅ Testimonial Extractor: Pull quotes from customer calls for social, blogs, landing pages, and more. ✅ Webinar → Blog Agent: Turn your Zoom/YouTube webinars into full blog posts, with research-baked content added in. ✅ Webinar → Socials Agent: Generate social content from webinars in seconds. ✅ ICP Rewriter: Instantly rewrite a blog post or email for a different audience (Enterprise, SMB, Developers etc.)

You’ll also learn:

→ How to customize these Agents for your brand → How to build your own (no code required) → How to make $$$ building AI Agents for others

AI won’t replace great marketers — but great marketers who use AI will replace those who don’t.

This guide walks through the process of generating four types of AI content in a single MindStudio agent:

1. Text

2. Image

3. Audio

This guide walks you through how to build structured forms in MindStudio that allow your AI agents to collect valuable information from users. You’ll learn how to create user input blocks, define variable names, configure form fields, and reference them inside prompts.

Planning the Form

In this example, we’re building a blog post generator. To create a more personalized AI output, we’ll collect the following information from the user:

This guide shows you how to create and deploy an AI agent designed to work within the MindStudio Chrome extension. You’ll learn how to configure the run mode, use webpage content as input, and set up a working summarizer agent from scratch.

Installing the Chrome Extension

1. Visit and click Install Chrome Extension.

MindStudio allows you to create internal data sources directly within your projects. These data sources are ideal for uploading documents—like support guides or product manuals—that your AI agents can reference to generate accurate, contextual responses.

Types of Data Sources

MindStudio supports several types of data sources:

• Integration data sources

Running independent workflow blocks in parallel can significantly reduce execution time for your AI agents. This approach is especially beneficial when multiple tasks can be performed simultaneously without waiting for each other’s results.

Example Scenario

An AI agent is designed to:

• Scrape multiple news websites

This guide walks you through creating two AI agents in MindStudio: a blog post generator and a Chrome extension-based summarizer. Along the way, you'll learn about workflows, variables, prompt design, and agent publishing.

Creating a New Agent

To start building:

1. Navigate to the Build tab in MindStudio.

2. Click Create New Agent.

3. You'll land inside the AI Editor on the automations canvas, where the workflow begins with a Start and End block.

Exploring Workflows and Variables

Workflows consist of functional blocks connected in sequence. Key block types include:

• User Input: Creates form fields and stores input as variables.

• Generate Text: Sends prompts to an AI model and returns text.

• Display Content: Displays output within the workflow (for testing or UI).

Working with Variables

Variables are created in form blocks and referenced using {{ double curly braces }}.

Best practice for prompt formatting:

Separate variables from instructions using custom tags.

Example:

This improves clarity and avoids formatting or grammatical issues when users input long or complex text.

Enhancing AI Prompts with Markdown Formatting

Use markdown formatting to improve the structure of the AI's output.

1. Add instructions: Make sure to use markdown formatting in your response.

2. Provide a template using example tags:

This gives the AI a clear outline to follow and leads to more consistent, polished outputs.

Publishing Your Agent

To publish your agent:

1. Click the root folder to open agent settings.

2. Provide a name, and optionally add a description, icon, or landing page.

3. Click Publish.

You can preview and re-publish at any time. Agents are private until explicitly shared.

Overview of AI Model Selection

Under Model Settings, you can:

• Choose from over 90 AI models by Anthropic, OpenAI, Google, Meta, and more.

• Adjust the temperature to control randomness:

  • Higher values = more variation

  • Lower values = more deterministic

Start with defaults and refine based on behavior and output quality.

Creating & Publishing a Summarizing Agent

To build a Chrome extension-based summarizer:

1. Create a new agent.

2. In the Start block, change the Run Mode to Browser Extension.

3. Use the launch variable page_content.

1. Name and publish your agent (e.g., Summarize Anything).

Once published, this agent can summarize:

• Website content

• YouTube transcripts

• PDFs and documents

It becomes available inside the MindStudio Chrome extension automatically.

Conclusion and Next Steps

You’ve now built:

• A blog post generator using structured markdown prompting.

• A content summarizer for the browser using launch variables.

Along the way, you learned:

• How to use variables and form inputs

• How to structure prompts for better output

• How to configure and select AI models

• How to publish and test your agents

These techniques will serve as your foundation for building more complex AI agents. Continue experimenting, iterating, and publishing as you expand your skills in future lessons.

This guide covers how to build more advanced AI workflows by chaining blocks together. You’ll learn how to take the output from one block, save it as a variable, and use it downstream to enrich prompts, create media, and display final outputs.

Overview: Blog Post Generator with Image

We’re building a multi-step blog post generator that does the following:

1. Collects a topic from the user.

2. Uses AI to generate an outline and key talking points.

3. Writes a full blog post using those points.

4. Generates a cover image based on the article.

5. Displays the final post and image together.

Step 1: Collect the Topic

• Add a User Input block.

• Input type: Short text.

• Variable name: topic

• Label: “What topic would you like to write about?”

Step 2: Brainstorm Key Points

• Add a Generate Text block.

• Prompt:

• In Output Behavior, select “Save to Variable”.

• Name the variable: key_points

Step 3: Generate the Blog Post

• Add another Generate Text block.

• Prompt:

• Save the output to a new variable: blog_post

Step 4: Create an Image Prompt

• Add another Generate Text block.

• Prompt:

• Save output to: image_description

Step 5: Generate the Image

• Add a Generate Image block.

• Use {{ image_description }} as the image prompt.

• Save image output to: image

Step 6: Display the Final Output

• Add a Display Content block.

• Use this markdown-style format to render both the image and blog content:

This combines everything into one nicely formatted response.

Testing the Workflow

Click Preview to open a draft and enter a test topic (e.g., “F1 cars and tech”). The AI will:

1. Generate an outline and key points.

2. Write the full blog post.

3. Generate an image description.

4. Create an image.

Use the Debugger to monitor each step:

• Track inputs and outputs.

• View how variables are resolved.

• Analyze each block’s execution.

Recap and Best Practices

• Chaining blocks means passing one block’s output as a variable to another block’s prompt.

• Use the Save to Variable setting to store data for reuse.

• Wrap variables with tags (e.g., <blog_post>{{ blog_post }}</blog_post>) to clarify structure.

• Use

Chaining is a core MindStudio principle that enables powerful, dynamic workflows. Practice chaining in small steps to build confidence and scale up to more complex agents.

Keep experimenting and expanding your workflows by connecting logic, generation, and media blocks together!

Generating HTML assets enables your AI agents to produce professional, styled web outputs—ideal for reports, articles, or visual summaries.

Overview of the Workflow

The example workflow builds a long-form article page through the following steps:

1. User Input: Captures a topic from the user.

2. User Context: Gathers additional context via AI-generated questions.

3. Generate Queries: Uses that context to generate relevant Google search queries.

4. Run Research Subworkflow:

   • Searches Google

   • Scrapes each result

   • Summarizes each page

5. Compile Results: Collects all structured data into a JSON object.

6. Generate Images: Runs a subworkflow that:

   • Creates image prompts from each article section

   • Generates images with a model

7. Combine Content: Uses a custom function (e.g., add images to report) to merge article JSON and images into a final, structured variable (e.g., updated report).

Preparing the HTML Asset

Step 1: Add a Generate Asset Block

• Set the Source Type to HTML.

• Output variable: e.g., HTML

• Format: HTML

Step 2: Create Your HTML Template

Expand the Source Document field to edit and preview your HTML. Use Handlebars-style syntax to bind JSON variables:

• Use {{#each}} and {{/each}} to loop through arrays.

• Nest variables properly based on your JSON structure.

Step 3: Provide Sample JSON for Testing

Paste in your sample JSON and variable name (e.g., updated_report) to preview the output live in the editor.

Optional: Use the Generate Asset Helper

If you don’t want to hand-code HTML:

• Use the Generate Asset Helper agent.

• Provide:

  • Your variable name (e.g., updated_report)

  • Sample JSON

The helper will:

• Ask design questions (layout, font, colors, spacing)

• Generate a complete HTML template

• Provide instructions to paste it into your asset block

Final Setup

Add a Display Content block:

• Set the type to HTML

• Connect it to the output of your Generate Asset block

Your AI agent will now generate and render a fully styled web page as the final output.

Styling and Customization

The HTML template can include embedded CSS using <style> tags. You can:

• Adjust fonts, spacing, and layout

• Change image border radius or alignment

• Modify heading sizes (e.g., h1, h2, h3)

Edit and preview changes instantly in the asset editor.

Notes on Variable Paths

When inserting dynamic content:

• Use full paths (e.g., {{updated_report.title}})

• Don’t reference standalone keys (e.g., {{title}}) unless the variable is defined globally

Summary

The Generate Asset block allows you to:

• Display highly customized HTML pages

• Combine AI-generated content and imagery

• Provide end users with a rich, professional experience

For advanced use cases, explore how other MindStudio agents (like “Generate LinkedIn Carousel” or “Generate Podcast”) implement this technique.

MindStudio supports two powerful types of variables that extend the functionality of your AI agents: Global Variables and Launch Variables. Each serves a distinct purpose and can help you build more advanced, persistent, and externally-driven workflows.

Global Variables

Global variables allow you to store values between workflow runs. This is useful when you want to retain state, keep a running record, or reference previous output in future executions.

Key Features:

• Prefixed with global.

• Stored project-wide and persist between agent runs

• Configurable from the Global Variables tab in the root project folder

Example: Story Generator

• A story-writing agent appends new chapters to a global variable called global.story.

• Each run checks if a story exists:

  • If it does: generates the next chapter.

  • If not: starts a new story.

This approach is ideal for accumulating content, maintaining histories, or building AI memory-like features.

Launch Variables

Launch variables allow you to inject data into your workflow at runtime, often via an external integration (e.g. API, webhooks, Make.com).

Key Features:

• Declared in the Start Block

• Replaces the need for user input blocks when running workflows programmatically

• Supports structured automation flows like onboarding forms, CRMs, or lead collection

Example: Sales Collateral via Google Form

• A Google Form collects company data (e.g. name, representative, company info).

• A Make.com automation sends these inputs into MindStudio as launch variables.

• The MindStudio workflow uses these variables to generate personalized sales content.

• The generated output is passed back and saved to a Google Sheet.

Launch variables streamline integrations and automate personalized content generation at scale.

Recap

By using global and launch variables strategically, you can create more intelligent, dynamic, and automated AI agents in MindStudio.

MindStudio provides four powerful block types that enable dynamic routing and decision-making in workflows. These are ideal for tailoring responses, segmenting processes, and incorporating human feedback.

Menu Block

Purpose: Presents users with a selectable menu to route them to different parts of a workflow.

How It Works:

Dynamic user inputs allow your AI workflows to adapt and respond to earlier outputs by presenting users with choices or prompts that reflect prior data. This approach makes your AI agents more interactive, relevant, and powerful.

Scenario: Extracting Entities from a Scraped URL

In a basic setup, you might scrape a URL and extract entities (e.g., people, organizations) mentioned in an article. The next step could involve presenting the user with these entities to choose one for further research.

To do this:

Using sub-workflows in MindStudio enables you to break out a specific task (like scraping a URL or generating summaries) and apply it repeatedly across a list of items. This approach is highly effective when dealing with variable-length structured data such as JSON arrays.

Why Use Sub-Workflows?

When dealing with dynamic lists (like search results or multiple URLs), manually duplicating logic is inefficient and error-prone. Instead, sub-workflows allow you to:

Once you have mastered the Context / Task / Format Framework, the next step is to make outputs cleaner, more reusable, and easier to plug into workflows.

When drafting your AI Prompts, there are patterns can help you turn your basic prompts into more advanced prompts:

• using Markdown,

• using variables

• tagging variables with XML.

These make your prompts readable for humans, reliable for the model, and predictable for downstream blocks.

Using Markdown

Markdown is a lightweight formatting language. It uses simple symbols like #, -, and * to add structure to text — things like headings, bold/italics, bullet lists, numbered lists, code blocks, and tables.

Why it matters in prompting:

1. Prompts become more readable. You can break up long instructions into clear sections instead of one big block of text.

2. Responses become more structured. You can tell the AI to output answers as Markdown so they’re consistent, readable, and easy to reuse in docs, tickets, or other tools.

Markdown formatting Quick Guide:

For more information, check out this to learn about different ways you can format text using Markdown.

Using Markdown in Prompts (for readability)

When you write a longer prompt, Markdown makes it easier for you (and teammates) to scan later. Adding Headings, lists, and code blocks turn your prompt into a mini instruction document rather than a wall of text.

Example:

Using Markdown in AI Responses (for template formatting)

You can also tell the AI to return its output in Markdown. This enforces a repeatable structure and prevents free-form answers that are hard to work with.

Example:

NOTE: Notice how in this example we use Markdown in both ways.

Using Variables

Variables let you insert dynamic values into prompts without rewriting them each time. In MindStudio, variables are always written in double curly braces: {{varName}}.

When your workflow runs, these variables are replaced with live data.

Why Variables Matter

• Personalization: Insert user inputs, or large data automatically.

• Reusability: Add the same variable as context in multiple places in your AI Agent.

• Flexibility: Variables can be used in across all blocks in MindStudio.

How They Look in a Prompt

When the workflow runs, {{customerName}} is replaced with the actual name and {{meetingNotes}} is filled with content from a transcript or notes block.

Good Habits

• Use descriptive names:

  • ❌ Bad variable names: var1 , a , xyz

  • ✅ Good variable names: renewalDate , firstName

Tagging Variables with XML Tags

Sometimes you’ll have multiple variables or large chunks of text. To keep things clear, make sure to wrap them in XML tags using <>.

Tagging allows you as a way to label different pieces of information for the AI model and shows the AI model where each label begins and ends.

How to Use XML Tags:

• Use opening tags: <tagName>

• Whatever content you want to label with tags goes in the middle. This can be a {{variable}} or plain text.

• At the end, make sure to close your tags with </tagName> . Notice the / before the tag name.

NOTE: This is standard practice across prompting across major model providers.

Why Tagging Your Variables Helps

• Separates multiple variables cleanly.

• Makes it easy for the AI to ground its answers to the right source.

• Helps AI Models can reliably extract specific values from data.

How XML Tags look in an AI Prompt

NOTE: Notice how in this example we use XML tags to label the example output in addition to labeling contextual information.

Context Engineering

Basic prompting is about clarity, and context engineering is about giving the AI the right information to work with. The more relevant and well-structured the context you provide, the more accurate and useful the AI’s answers will be.

If you don’t give the AI model the background materials they need to complete the task, it will just make things up. On the other hand, if you give the AI model too much information with no guidance, they’ll get overwhelmed.

Context engineering is how you give just the right amount of background, in the right way.

Why Context Matters:

• Grounding: Prevents the AI from guessing by supplying the facts it should rely on.

• Relevance: Keeps answers tied to your data, not general internet knowledge.

• Control: Lets you shape the “memory” of the model so it stays on task.

Context Engineering Techniques

1. System Prompt

In the System Prompt Tab, can include a prompt to guide the AI’s behavior or provide global information that you’d like your AI Agent to know about. This acts like the intern’s “job description.”

Example:

2. Reference Materials

You can inject documents, transcripts, notes, or snippets directly into the prompt. This ensures the AI bases its answer on your content, not what it happens to know.

3. Instruction Hierarchy

Make it clear which rules take priority.

Example:

“Always base your answer on the supplied transcript, even if you know other information.”

4. Variables + Tags

Use {{variables}} to pass in dynamic context like customer names, transcripts, or notes. Wrap large chunks in <tags> so the AI knows where they begin and end.

Prompt Example (with Context Engineering)

Good Practices:

• Keep context relevant — don’t paste in entire documents if only one section matters.

• Segment long text with clear tags so the AI doesn’t confuse sources.

• Be explicit: tell the AI to “only use the supplied material.”

Prompt Writing Checklist

• Did you provide enough background info for the AI to understand the request?

• Did you limit context to only what’s relevant?

• Did you tag variables or long text so the AI can clearly separate them?

• Did you tell the AI which context takes priority?