> ## Documentation Index
> Fetch the complete documentation index at: https://helpcenter.magure.ai/llms.txt
> Use this file to discover all available pages before exploring further.
# 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](/quickstart) 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
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.
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
1. Create a new **Use Case** called "Company Research"
2. Open the **Canvas**
3. Add two **Agent** nodes and connect them: **Start** → **Agent 1** → **Agent 2** → **End**
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.
```json theme={null}
{
"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
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
```json theme={null}
{
"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
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
1. Upload a CSV file (sales data, employee list, product catalog — anything)
2. Run the workflow:
```json theme={null}
{
"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
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.
1. Upload a PDF (a contract, proposal, policy document — anything)
2. Run the workflow:
```json theme={null}
{
"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:
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:
Multi-agent parallel research with CRM integration
Process identity documents with private vision models
Automated support ticket classification and routing
Five parallel specialist agents analyzing procurement proposals