Skip to main content
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

ComponentDetails
ToolsNone
ModelAny — fast models work well for classification
Agents5 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

1

Create the use case and build the workflow

  1. Create a new Use Case called “Support Router”
  2. Open the Canvas
  3. Add an Agent node for the Classifier — click on it and configure the agent name, persona, and model directly in the properties panel
  4. Add a Condition node — use expression-based routing:
    • Check the classifier’s intent output field
    • Create four branches: billing, technical, sales, general
  5. Add an Agent node on each branch — configure each with the corresponding specialist persona
  6. 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.
2

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

ComponentDetails
ToolsWeb Search
ModelGPT-4o or Claude recommended
Agents2 (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

1

Create the use case and build the workflow

  1. Create a new Use Case called “Company Research”
  2. Open the Canvas
  3. Add two Agent nodes and connect them: StartAgent 1Agent 2End
  4. Click the first Agent node — configure it as “Company Researcher” with the persona above, add the Web Search tool, and enable tool execution
  5. 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.
2

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

ComponentDetails
ToolsWeb Search
ModelAny
Agents2 (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

1

Create the use case and build the workflow

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

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

ComponentDetails
ToolsFile Tools (built-in, no setup)
ModelGPT-4o or Claude recommended (better with data)
Agents1 (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

1

Create the use case and build the workflow

  1. Create a new Use Case called “CSV Analyzer”
  2. Open the Canvas
  3. 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
  4. 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)
  5. Connect to the End node
2

Test it

  1. Upload a CSV file (sales data, employee list, product catalog — anything)
  2. 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

ComponentDetails
ToolsFile Tools (built-in)
ModelGPT-4o or Claude recommended
Agents4 (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

1

Create the use case and build the workflow

  1. Create a new Use Case called “Document Reviewer”
  2. Open the Canvas
  3. Add a Tool node after Start — configure it to use File Tools with extract_pdf_sections to extract text
  4. 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
  5. After the Parallel node, add an Agent node — configure as “Summary Writer” with its persona
  6. 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.
2

Test it

  1. Upload a PDF (a contract, proposal, policy document — anything)
  2. 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:
PatternWhen to useExampleTools needed
Single agentSimple tasks with one LLM callWeb research, text generationOptional
Agent chainTasks that benefit from specialized stepsResearch → Report, Classify → RespondOptional
Parallel agentsIndependent analysis or researchMulti-source research, parallel reviewsOptional
Conditional routingDifferent paths based on input or outputSupport routing, pass/fail decisionsNone
Tool + AgentExtract data, then analyze with LLMCSV analysis, PDF reviewFile Tools
Agent + ToolAgent reasons, tool executesWeb search, database queriesWeb 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:
  1. Support Router (2 min) — fastest to build, zero tools, shows conditional branching
  2. Company Research (3 min) — shows web search + agent chaining
  3. Parallel Competitor Analysis (3 min) — the visual wow moment with parallel execution
  4. CSV Data Analyzer (3 min) — shows file upload + data analysis
  5. Document Reviewer (5 min) — combines everything: file tools + parallel + synthesis
Each builds on the previous, introducing one new concept at a time.

What’s next?

Ready for more advanced workflows with external integrations (email, calendar, CRM)? Check out the full cookbooks:

Sales intelligence

Multi-agent parallel research with CRM integration

KYB document verification

Process identity documents with private vision models

IT support triage

Automated support ticket classification and routing

RFP proposal analysis

Five parallel specialist agents analyzing procurement proposals