5 bots you can build today

Quick, practical AI bot recipes — each takes under 10 minutes. No OAuth setup required.

Five ready-to-build bots using only tools that work out of the box — web search, file tools, and pure LLM (no tools). No OAuth setup, no API keys to configure, no external accounts needed.

New to MagOneAI? Complete the Quickstart guide first to build your first bot — these recipes build on those concepts.

1. Smart support router

Classifies incoming messages and routes them to specialized agents. No tools needed — pure LLM intelligence. This is the fastest bot to build and the best one to demo.

Workflow

START --> Agent (Classifier) --> Condition (intent)
    |-- billing    --> Agent (Billing Specialist)    --> END
    |-- technical  --> Agent (Tech Support)          --> END
    |-- sales      --> Agent (Sales Rep)             --> END
    |-- general    --> Agent (General Assistant)      --> END

What you need

Component	Details
Tools	None
Model	Any — fast models work well for classification
Agents	5 total (1 classifier + 4 specialists)

Agent personas

Classifier Agent:

You are a customer support classifier. Analyze the customer's message
and classify their intent.

Output exactly one of:
- billing (payment issues, invoices, subscriptions, refunds)
- technical (bugs, errors, how-to questions, integrations)
- sales (pricing questions, upgrades, new features, demos)
- general (everything else)

Output JSON: { "intent": "billing|technical|sales|general", "confidence": 0.0-1.0, "summary": "brief summary" }

Specialist agents — create one for each category with domain-specific instructions. For example:

Billing Specialist:

You are a billing support specialist. Help customers with payment issues,
invoice questions, subscription changes, and refunds.

Be empathetic and solution-oriented. If you cannot resolve the issue,
clearly explain the escalation path.

Build it

Create the use case and build the workflow

Create a new Use Case called "Support Router"
Open the Canvas
Add an Agent node for the Classifier — click on it and configure the agent name, persona, and model directly in the properties panel
Add a Condition node — use expression-based routing:
- Check the classifier's intent output field
- Create four branches: billing, technical, sales, general
Add an Agent node on each branch — configure each with the corresponding specialist persona
Connect each specialist to an End node

All 5 agents are created right inside the canvas as you build the workflow. No separate agent creation step needed.

Test it

Try different inputs:

"I was charged twice for my subscription" → billing
"The API returns a 500 error" → technical
"Do you offer enterprise pricing?" → sales
"What are your office hours?" → general

This is the best recipe to demo live — it's fast to build, needs zero tool setup, and visually shows branching logic on the canvas. The audience immediately understands conditional routing.

2. Company research report

Research any company using web search and produce a structured report. Shows tool integration and how agents reason with real-time data.

Workflow

START --> Agent (Company Researcher) --> Agent (Report Writer) --> END

What you need

Component	Details
Tools	Web Search
Model	GPT-4o or Claude recommended
Agents	2 (researcher + report writer)

Agent personas

Company Researcher:

You are a business research analyst. Given a company name, use web search
to find current, accurate information.

Research and gather:
1. What the company does (products/services, industry)
2. Size and scale (employees, revenue, funding)
3. Recent news (last 3-6 months)
4. Key leadership
5. Competitors

Search multiple times to get comprehensive coverage. Use specific queries
like "[Company] funding 2025" or "[Company] CEO leadership team".

Output structured JSON with your findings and source URLs.

Report Writer:

You are a business report writer. You receive raw research findings
from a research analyst.

Produce a clean, professional company brief:

1. Executive Summary (2-3 sentences)
2. Company Overview (what they do, size, HQ)
3. Leadership Team
4. Recent Developments (top 3 news items)
5. Competitive Landscape
6. Sources

Write in clear, professional language. Format as clean Markdown.
Keep it to one page — concise and actionable.

Build it

Create the use case and build the workflow

Create a new Use Case called "Company Research"
Open the Canvas
Add two Agent nodes and connect them: Start → Agent 1 → Agent 2 → End
Click the first Agent node — configure it as "Company Researcher" with the persona above, add the Web Search tool, and enable tool execution
Click the second Agent node — configure it as "Report Writer" with its persona (no tools needed)

The implicit chaining automatically passes the researcher's output to the report writer.

Test it

{
  "company": "Anthropic"
}

The researcher searches the web multiple times, the report writer produces a polished brief. Takes about 15-30 seconds.

Why two agents instead of one? Separating research from writing produces better results. The researcher focuses on finding accurate data, the writer focuses on clear communication. This is a core MagOneAI pattern — specialized agents chained together.

3. Parallel competitor analysis

Research three competitors simultaneously using parallel agents, then synthesize into a comparison. Shows the power of parallel execution.

Workflow

START --> Parallel
    |-- Agent (Researcher 1) --> searches competitor A
    |-- Agent (Researcher 2) --> searches competitor B
    |-- Agent (Researcher 3) --> searches competitor C
    --> Agent (Comparison Analyst) --> END

What you need

Component	Details
Tools	Web Search
Model	Any
Agents	2 (1 reusable researcher + 1 analyst)

Agent personas

Competitor Researcher (reused across all 3 branches):

You are a competitive intelligence researcher. Given a company name,
search the web and gather:

1. Products and pricing (if public)
2. Target customers and positioning
3. Recent product launches or announcements
4. Strengths and weaknesses
5. Customer sentiment (from reviews, social media)

Be thorough. Search for "[Company] pricing", "[Company] reviews",
"[Company] vs competitors" to get comprehensive coverage.

Output structured JSON with findings.

Comparison Analyst:

You are a competitive intelligence analyst. You receive research on
multiple competitors.

Create a comparison report:

1. Side-by-Side Comparison Table
   - Features, pricing, target market, strengths, weaknesses
2. Key Differentiators
   - What makes each competitor unique
3. Market Positioning Map
   - Describe where each player sits
4. Strategic Recommendations
   - Opportunities and threats based on the analysis

Format as clean Markdown with tables.

Build it

Create the use case and build the workflow

Create a new Use Case called "Competitor Analysis"
Open the Canvas
Add a Parallel node with three branches after the Start node
Add an Agent node in each branch — configure each as "Competitor Researcher" with the persona above, add Web Search tool, and enable tool execution
After the Parallel node, add an Agent node — configure as "Comparison Analyst" with its persona (no tools needed)
Connect to the End node
Map each branch's input to a different competitor from the input list

Test it

{
  "industry": "Project Management",
  "competitors": ["Asana", "Monday.com", "ClickUp"]
}

All three researchers run simultaneously (~20s total instead of ~60s sequential). The analyst then synthesizes into a comparison report.

This is the most visually impressive demo. The canvas shows three branches running at the same time, and the execution logs show parallel timing. Great for showing MagOneAI's orchestration power.

4. CSV data analyzer

Upload a CSV file, extract the data, and have an agent analyze it and answer questions. Shows file processing and data analysis without needing a database connection.

Workflow

START --> Tool (Extract CSV Rows) --> Agent (Data Analyst) --> END

What you need

Component	Details
Tools	File Tools (built-in, no setup)
Model	GPT-4o or Claude recommended (better with data)
Agents	1 (data analyst)

Agent persona

Data Analyst:

You are a data analyst. You receive structured data (rows from a CSV file)
and a question about the data.

Your job:
1. Understand the data structure (columns, types, row count)
2. Analyze the data to answer the question
3. Calculate any relevant statistics
4. Identify patterns, outliers, or trends
5. Present findings clearly

Rules:
- Show your work — explain how you calculated results
- Use tables to present data comparisons
- Round numbers to 2 decimal places
- If the data can't answer the question, say so clearly
- Suggest follow-up analyses the user might find useful

Format your response as:
- Summary (2-3 sentences answering the question)
- Detailed Findings (tables, calculations)
- Recommendations (if applicable)

Build it

Create the use case and build the workflow

Create a new Use Case called "CSV Analyzer"
Open the Canvas
Add a Tool node after Start — configure it to use the File Tools MCP server with the extract_rows tool, mapping file_id from the Start input
Add an Agent node after the Tool node — configure it as "Data Analyst" with the persona above (no tools needed — the data comes from the Tool node before it)
Connect to the End node

Test it

Upload a CSV file (sales data, employee list, product catalog — anything)
Run the workflow:

{
  "file_id": "uuid-of-uploaded-file",
  "question": "What are the top 5 products by revenue, and what's the average order value?"
}

The Tool node extracts the CSV into structured rows, then the agent analyzes and answers.

Prepare a sample CSV file before your demo (e.g., 50 rows of sales data with columns like product, revenue, region, date). Upload it beforehand so you can run the bot instantly during the walkthrough.

5. Document reviewer with parallel checks

Upload a PDF or document, extract its content, then run multiple review agents in parallel. Shows file processing + parallel analysis + synthesis.

Workflow

START --> Tool (Extract PDF Sections) --> Parallel
    |-- Agent (Clarity Reviewer)
    |-- Agent (Completeness Checker)
    |-- Agent (Risk Flagger)
    --> Agent (Summary Writer) --> END

What you need

Component	Details
Tools	File Tools (built-in)
Model	GPT-4o or Claude recommended
Agents	4 (3 parallel reviewers + 1 synthesizer)

Agent personas

Clarity Reviewer:

You are an expert editor reviewing a document for clarity and readability.

Check for:
- Jargon or overly complex language
- Ambiguous statements or unclear requirements
- Missing definitions for technical terms
- Inconsistent terminology
- Sentences that are too long or convoluted

For each issue found, provide:
- The problematic text (quote it)
- Why it's unclear
- A suggested improvement

Output JSON: { "issues": [...], "clarity_score": 1-10, "summary": "..." }

Completeness Checker:

You are a document completeness auditor.

Check whether the document includes:
- Clear purpose or objective statement
- Scope and boundaries
- Key terms defined
- All sections referenced in the table of contents
- Contact information or responsible parties
- Dates (effective date, review date, expiry)
- Version number

For each missing element, explain why it matters.

Output JSON: { "missing_elements": [...], "completeness_score": 1-10, "summary": "..." }

Risk Flagger:

You are a risk analyst reviewing documents for potential issues.

Flag any:
- Liability or indemnification concerns
- Ambiguous obligations or deadlines
- Missing approval requirements
- Compliance gaps (data privacy, regulatory)
- Unrealistic commitments or timelines
- Single points of failure

For each risk:
- Severity: HIGH / MEDIUM / LOW
- Description of the risk
- Recommended mitigation

Output JSON: { "risks": [...], "risk_score": 1-10, "summary": "..." }

Summary Writer:

You are a senior reviewer who synthesizes findings from three specialist
reviewers: Clarity, Completeness, and Risk.

Produce a single review report:

1. Overall Assessment (PASS / NEEDS REVISION / REJECT)
2. Scores: Clarity X/10, Completeness X/10, Risk X/10
3. Critical Issues (must fix before approval)
4. Recommended Improvements (should fix)
5. Minor Suggestions (nice to have)

Keep it actionable. Prioritize by impact.
Format as clean Markdown.

Build it

Create the use case and build the workflow

Create a new Use Case called "Document Reviewer"
Open the Canvas
Add a Tool node after Start — configure it to use File Tools with extract_pdf_sections to extract text
Add a Parallel node with three branches:
- Branch 1: Add an Agent node, configure as "Clarity Reviewer" with its persona
- Branch 2: Add an Agent node, configure as "Completeness Checker" with its persona
- Branch 3: Add an Agent node, configure as "Risk Flagger" with its persona
After the Parallel node, add an Agent node — configure as "Summary Writer" with its persona
Connect to the End node

All agents are created directly in the canvas as you add each node. No tools needed for any agent — they all receive the document content from the Tool node.

Test it

Upload a PDF (a contract, proposal, policy document — anything)
Run the workflow:

{
  "file_id": "uuid-of-uploaded-pdf"
}

Three reviewers analyze in parallel (~20s), then the summary writer produces a comprehensive review with scores and recommendations.

Patterns cheat sheet

Every bot above uses one or more of these patterns. Mix and match to build your own:

Pattern	When to use	Example	Tools needed
Single agent	Simple tasks with one LLM call	Web research, text generation	Optional
Agent chain	Tasks that benefit from specialized steps	Research → Report, Classify → Respond	Optional
Parallel agents	Independent analysis or research	Multi-source research, parallel reviews	Optional
Conditional routing	Different paths based on input or output	Support routing, pass/fail decisions	None
Tool + Agent	Extract data, then analyze with LLM	CSV analysis, PDF review	File Tools
Agent + Tool	Agent reasons, tool executes	Web search, database queries	Web Search

Start with the simplest pattern that works. A single-agent bot can be surprisingly powerful. Add complexity only when you need it — parallel execution, conditional logic, and human approval are easy to add later.

Demo order recommendation

If you're showing these in a walkthrough, this order works best:

Support Router (2 min) — fastest to build, zero tools, shows conditional branching
Company Research (3 min) — shows web search + agent chaining
Parallel Competitor Analysis (3 min) — the visual wow moment with parallel execution
CSV Data Analyzer (3 min) — shows file upload + data analysis
Document Reviewer (5 min) — combines everything: file tools + parallel + synthesis

Each builds on the previous, introducing one new concept at a time.

5 bots you can build today

Create the use case and build the workflow

Test it

Create the use case and build the workflow

Test it

Create the use case and build the workflow

Test it

Create the use case and build the workflow

Test it

Create the use case and build the workflow

Test it

Sales intelligence

KYB document verification

IT support triage

RFP proposal analysis

On this page