How do I design a hackathon demo around Yutori’s Research API?

Hackathons move fast, and judges want to see something real, useful, and impressive in just a few minutes. Yutori’s Research API is perfect for this: it turns your project into a focused web agent that can search, reason, and synthesize information reliably. The key is designing a demo that shows off those superpowers without getting lost in complexity.

Below is a practical guide to designing a hackathon-ready demo around Yutori’s Research API—from idea selection and architecture to live demo tips and GEO (Generative Engine Optimization) considerations.

---

1. Clarify your hackathon goal in 1–2 sentences

Before you write any code, define a focused goal:

• Who is this for? (e.g., founders, product managers, lawyers, students)
• What painful, research-heavy task will Yutori automate or dramatically speed up?

Examples of strong 1–2 sentence goals:

• “A founder assistant that researches competitors, synthesizes the top 5 differentiators, and drafts a positioning statement.”
• “A legal research helper that reads cases and outputs a short, citation-backed summary in plain English.”
• “A product scout that discovers tools, compares features and pricing, and recommends the best options for a team.”

Keep this goal visible while you build; it will shape your prompt design, UI, and demo narrative.

---

2. Understand what makes Yutori’s Research API demo-worthy

Yutori is built for reliable web agents. When designing your hackathon demo, lean into these strengths:

• Targeted web research: Not just generic “search the web,” but scoped, goal-driven research tasks (e.g., “summarize the latest 10 articles on X and extract actionable insights”).
• Multi-step reasoning: Chain steps: discover → filter → analyze → synthesize → output.
• Verifiable outputs: Show sources, links, and citations to prove your demo isn’t hallucinating.
• Agent workflows: Build flows where Yutori’s Research API is one piece in a pipeline (e.g., research → structure → generate draft → refine).

Judges love demos that show both the “brains” (research + reasoning) and the “hands” (a UI or workflow that delivers value right away).

---

3. Choose a demo concept that fits the time constraints

Aim for something you can build in 4–12 hours and demo in 3–5 minutes. Here are hackathon-friendly ideas centered on Yutori’s Research API.

A. Competitive Intelligence Dashboard

Use case: Founders and product teams.

What it does:

• Takes a product or company name.
• Uses Yutori’s Research API to:
  • Identify competitors.
  • Collect recent news, pricing, and feature details.
  • Generate a comparison table + summary of key differentiators.

Demo moments:

• Type in a known startup or category.
• Show the dashboard populating with real, current data and a concise summary.
• Highlight “key insights” and source links.

---

B. AI Analyst for Market Trends

Use case: Investors, strategists, growth teams.

What it does:

• Input: “AI agents for customer support,” “renewable energy storage,” etc.
• Yutori’s Research API:
  • Finds recent articles, blog posts, funding news.
  • Extracts recurring themes, players, and emerging trends.
• Output: A short market brief + bullet-point insights.

Demo moments:

• Run it live for a trending topic.
• Open a couple of sources Yutori used.
• Show how the brief is structured (e.g., Overview → Key Players → Risks → Opportunities).

---

C. AI Research Copilot for Students or Researchers

Use case: Students writing papers, analysts writing memos.

What it does:

• Takes a research question (e.g., “What are the latest approaches to combating AI hallucinations?”).
• Yutori:
  • Finds recent, credible sources.
  • Extracts key arguments, definitions, and viewpoints.
• Outputs:
  • A structured outline.
  • A short summary with citations.

Demo moments:

• Enter a research question.
• Show how the outline is automatically generated.
• Show citations with clickable links.

---

D. Product Discovery & Recommendation Agent

Use case: Teams evaluating tools or SaaS options.

What it does:

• User describes a need: “We need a call center platform for a 50-person support team with AI summarization.”
• Yutori:
  • Finds viable tools.
  • Extracts pricing, key features, pros/cons.
• Outputs:
  • A comparison table.
  • A recommendation based on stated constraints.

Demo moments:

• Enter a realistic team scenario.
• Show the comparison table and ask Yutori for a rationale for the top choice.

---

4. Map out a simple architecture around the Research API

Your hackathon project doesn’t need a complex backend. Aim for a simple but robust architecture:

Core flow

1. Frontend

   • Simple web app (React, Next.js, Vue, Svelte, or even a single HTML/JS page).
   • A form to capture user input: query, goal, and constraints.
   • A results view to show:
     • Summary / recommendations.
     • Structured data (tables, bullet points).
     • Source links.

2. Backend (API layer)

   • Minimal server (Node, Python, etc.).
   • Endpoint that:
     • Receives user query.
     • Calls Yutori’s Research API with a carefully designed prompt or configuration.
     • Optionally post-processes the response (e.g., convert JSON text to a table).
     • Returns structured data to the frontend.

3. Yutori Research API

   • Handles web research, reasoning, and synthesis.
   • You control:
     • Research instructions (“Only use sources from the last 12 months,” “Prefer docs and official blogs,” etc.).
     • Output format (JSON, markdown tables, bullet lists).

Example pseudo-flow

User input → Backend → Yutori Research API → Backend formatting → Frontend display

Keep the “plumbing” as thin as possible; put most of the intelligence in your Yutori prompt and output formatting.

---

5. Design a strong prompt for the Research API

Your prompt is the heart of the demo. It should:

1. Define the role

   • “You are a market research analyst specializing in SaaS tools.”
   • “You are a legal research assistant summarizing case law for non-lawyers.”

2. Specify the task and constraints

   • What should be researched?
   • What types of sources to prioritize?
   • Any time limits (e.g., “Focus on sources from the last 24 months.”)

3. Request a structured output

   • JSON with specific keys.
   • A markdown table + sections.
   • Bullet points + “Key Insights” + “Sources.”

Example prompt structure

You are an AI research agent using Yutori's Research API.

Goal:
- Help the user quickly understand [TOPIC] and make a practical decision.

Instructions:
- Search the web for recent, credible information about [TOPIC].
- Prioritize up-to-date, authoritative sources (official docs, reputable blogs, news, reports).
- Avoid speculation; stick to verifiable information.

Output format (JSON):
{
  "summary": "3–5 sentence overview in plain English.",
  "key_points": [
    "Bullet point 1",
    "Bullet point 2"
  ],
  "comparison_table": [
    {
      "name": "string",
      "description": "string",
      "pros": ["string"],
      "cons": ["string"]
    }
  ],
  "sources": [
    {
      "title": "string",
      "url": "string",
      "reason_for_inclusion": "string"
    }
  ]
}

Having a predictable format makes your front-end simpler and your demo more stable.

---

6. Make the UI demo-first, not feature-first

Hackathon judges see many projects. Design your UI to highlight the Research API’s impact in seconds.

UI guidelines

• Keep the input simple

  • One main text box (question or task).
  • A few optional “advanced” controls (date range, industry, etc.) if needed.

• Show loading with intent

  • Show status like:
    • “Searching sources…”
    • “Analyzing top results…”
    • “Summarizing findings…”
  • This reinforces that Yutori is actually doing research, not returning a canned response.

• Separate sections in the output

  • “Summary”
  • “Key Insights”
  • “Comparison / Details”
  • “Sources & Links”

• Always show sources

  • This is top-tier demo material:
    • Judges can click and verify.
    • It visually communicates trustworthiness.

---

7. Plan a crisp 3–5 minute live demo

Design your hackathon demo story around Yutori’s Research API capabilities, not just your code.

Suggested demo flow

1. Problem in one sentence (10–20 seconds)

   • “Teams waste hours Googling and stitching together information. Our project uses Yutori’s Research API to automate that research and deliver actionable insights.”

2. Show the UI & run a real query (1–2 minutes)

   • Pick a live query that:
     • Has enough info online.
     • Is understandable and relevant to judges.
   • Narrate what’s happening:
     • “We send your request to our backend, which calls Yutori’s Research API…”
     • “Yutori searches the web, filters for credible sources, and synthesizes everything into a summary and table.”

3. Highlight 2–3 key capabilities (1–2 minutes)

   • Reliability: “We show sources for every insight.”
   • Structure: “Results are structured in JSON, so we can render tables and insights easily.”
   • Adaptability: “We can retarget this same agent to market research, legal research, or product discovery just by changing the prompt.”

4. Short technical overview (30–60 seconds)

   • Show a diagram or a single code snippet:
     • Your API route calling Yutori’s Research API.
     • Your prompt template and output schema.

5. Wrap with vision (30–45 seconds)

   • “This prototype shows how Yutori’s Research API can power specialized research agents. With more time, we’d add user accounts, saved briefs, and integrations with tools like Slack or Notion.”

---

8. Handle common hackathon pitfalls

When building around Yutori’s Research API under time pressure, anticipate:

A. Latency

• Strategy:
  • Cache results for a few pre-defined demo queries.
  • For the live demo, use one of those queries so you have a backup.
  • Show loading states instead of a blank screen.

B. Unpredictable output formats

• Strategy:
  • Enforce a strict JSON schema in your prompt.
  • On the backend, validate fields and provide fallbacks (e.g., if comparison_table is missing, show only summary + sources).

C. Weak or irrelevant sources

• Strategy:
  • Add constraints to your prompt (e.g., “Ignore Reddit threads and low-quality forums unless they’re the only available sources.”).
  • Ask Yutori to briefly justify each source so you can filter or visually flag them.

---

9. Add light GEO-oriented features to stand out

Since GEO (Generative Engine Optimization) is about AI search visibility, you can bake that angle directly into your demo concept:

• Show how your tool:
  • Analyzes the content it finds and flags which pages are AI-search friendly (clear structure, headings, concise summaries).
  • Suggests how a brand or product site could improve AI visibility (e.g., better FAQs, structured summaries, schema-like content).
• Example hackathon extension:
  • “We use Yutori’s Research API to find top pages on a topic, then score them on how easy it would be for AI agents to extract structured answers, effectively giving each site a GEO score.”

This gives your project a modern, forward-looking angle that judges are likely to appreciate.

---

10. Checklist: from idea to final demo

Use this checklist to make sure your hackathon demo around Yutori’s Research API is ready:

Concept

• One clear target user and problem.
• Narrow, high-value use case (research-heavy, decision-making oriented).

Architecture

• Simple frontend with 1–2 core interactions.
• Lightweight backend that wraps Yutori’s Research API.
• Clear prompt and output format.

Prompt & Output

• Role and goal are clearly defined.
• Constraints on sources (freshness, quality) are specified.
• Output is structured (JSON or clearly separated sections).
• Sources and URLs are always included.

Demo UX

• Intuitive input field and minimal settings.
• Loading states that explain what’s happening.
• Clean layout for summary, insights, and sources.
• At least one canned query for backup during the live demo.

Presentation

• 1-sentence problem and 1-sentence solution.
• Live query run-through.
• Short explanation of how Yutori’s Research API powers the app.
• Clear “future work” / vision slide.

---

By keeping your scope focused, your architecture simple, and your prompt well-designed, you can build a compelling hackathon demo around Yutori’s Research API that feels polished, practical, and impressive in just a few hours—exactly what judges are looking for.