Personalized Information Booklet
Ideas Found
Previous Companies Found
Customized Build Plan

Scout

See the story behind your idea before you build it.

Inspiration

Every hackathon starts the same way.

Someone says an idea out loud.
The team gets excited.
Everyone agrees it sounds promising.
The pitch starts forming.
The features start making sense.

Then someone finally searches it properly and realizes:

“Wait… this already exists.”

Sometimes it was a Devpost project from years ago. Sometimes it was a GitHub repo that got abandoned. Sometimes it was a startup that launched, pivoted, and quietly disappeared. Sometimes it is still alive, but with one obvious weakness nobody has fixed.

That moment is frustrating because the idea does not suddenly feel bad. It just feels like the team found the story too late.

The problem is not that ideas have been built before. Most good ideas have. The problem is that the history of an idea is usually invisible when a team is deciding what to build.

Hackathon teams usually agree first and research later. By then, they are already attached.

We wanted to reverse that.

What if, before committing to an idea, a team could see who tried it, what worked, what failed, what still exists, and how their version could actually be different?

That became Scout.

What it does

Scout turns a hackathon idea into a narrative research experience.

A user types in an idea, like “AI study buddy,” “mental health journaling app,” or “calendar assistant for students.” Scout researches the history around that idea and turns it into a structured story of previous attempts, current competitors, repeated failure patterns, and remaining opportunities.

Instead of giving users a generic research report, Scout reveals the idea’s history like a three-act story.

Users can:

Enter a hackathon idea
Discover similar projects that already existed
See what those projects did well
Learn what they missed or failed to solve
Find current competitors
Identify repeated failure patterns across related ideas
Understand the gap that still exists
Generate a build plan for how to approach the idea differently

Scout is built for the start of a hackathon, when teams are deciding what to build and how to make it original.

The goal is simple:

Help builders understand the story of an idea before they become the next chapter.

Storytelling through technology

Scout was designed around the theme of storytelling through technology.

Most research tools treat information as something to summarize. Scout treats information as something to experience.

When a user submits an idea, Scout does not immediately show a dense research page. It reveals the history in stages.

First, the user sees past attempts.
Then they see what happened to each one.
Then comes the turn: the recurring pattern that explains why similar ideas struggled.
Then Scout shows the living competitors, the remaining gap, and whether now is the right time to build.

The story is not just:

“Here are some competitors.”

The story is:

People have tried this before.
Here is what happened.
Here is what they missed.
Here is how you can avoid repeating it.
Here is how your version can become the next chapter.

That is where the technology becomes the storytelling medium.

Backboard gives Scout the memory and multi-agent structure to collect the story across sessions. Gemini helps Scout research, reason, and shape scattered evidence into a clear narrative. The frontend reveals that story in stages, so the user feels the weight of what came before before deciding what to build next.

Scout does not just answer, “Has this been built before?”

It tells the story of the idea.

And once a team understands that story, they can build a better ending.

How we used Backboard

Backboard was the spine of Scout, and one of our main goals was to push it as far as we could during the hackathon.

We did not want to use Backboard as a simple chatbot backend or a single AI call. We wanted to build something that actually used Backboard as an AI operating system: multiple agents, persistent memory, semantic recall, structured outputs, and long-running coordination across a full research pipeline.

Scout uses seven Backboard-powered agents:

Idea Expander
Research Scout
Historian
Landscape Agent
Pattern Agent
Synthesis Agent
Builder Agent

Each agent has one job, one structured JSON contract, and one role in the story.

The Idea Expander turns rough ideas into better search angles. The Research Scout finds grounded evidence from public sources. The Historian turns that evidence into a timeline. The Landscape Agent finds current competitors. The Pattern Agent searches Backboard memory for similar past searches. The Synthesis Agent finds the remaining gap. The Builder Agent turns everything into a practical MVP plan.

Backboard also gave Scout persistent memory.

Every completed idea search gets written into a shared Backboard memory graph with structured metadata, including:

Idea text
Failure signals
Competitors
Source domains
Research quality
Final turn sentence

When a new user searches an idea, Scout uses Backboard semantic recall to find adjacent ideas from previous searches. For example, a search for “AI study buddy” can connect to older searches like “AI tutor,” “homework helper,” “flashcard generator,” and “lecture summarizer.”

That makes Scout more than a one-time research tool. Every search makes the next search smarter.

We also designed every agent as a separate Backboard stage so we could take advantage of model flexibility and hot-swapping. Since Backboard supports access to thousands of models, Scout’s architecture is built so individual agents can be swapped or tuned independently. If one model performs better for research and another works better for synthesis, the pipeline can support that without rewriting the whole app.

We also treated Scout’s evidence archive like a RAG-style research bundle. The Research Scout collects sources, the Historian and Landscape Agent retrieve from that evidence, and the Pattern Agent combines it with Backboard’s semantic memory graph. That lets Scout reason over both the current idea’s public evidence and older related searches.

Backboard made Scout feel less like a chatbot and more like infrastructure for idea intelligence.

How we used Gemini

Gemini powered the reasoning and research inside Scout.

We used the Gemini API in two main ways.

The first was grounded research.

For the Research Scout, Historian, and Landscape Agent, we used Gemini with Google Search grounding to help Scout find real public evidence. This was important because Scout depends on actual project history. A made-up Devpost project, fake startup, or hallucinated competitor would break the experience.

Gemini helped Scout find:

Past hackathon projects
GitHub repositories
Product launches
Startup pages
Public discussions
Postmortems
Competitor websites
Failure signals

The second was structured reasoning.

For the Idea Expander, Pattern Agent, Synthesis Agent, and Builder Agent, we used Gemini to return clean structured outputs that could move through the pipeline.

Gemini helped Scout:

Expand rough ideas into better search terms
Turn scattered evidence into a timeline
Identify recurring failure patterns
Write the “turn” sentence in the story
Generate the opportunity gap
Produce a practical build plan

We also added safeguards around Gemini’s outputs. Scout validates JSON responses, checks URLs, deduplicates sources, normalizes evidence, and falls back gracefully when an agent does not return enough data.

The most important Gemini moment was the storytelling layer. Gemini did not just summarize research. It helped turn scattered evidence into a narrative arc:

Past attempts.
Repeated mistakes.
Current competitors.
Remaining opportunity.
Next build move.

That is what made Scout fit the storytelling through technology theme.

The agent pipeline

Scout is built as a seven-agent pipeline.

Agent 1 - Idea Expander

Most hackathon ideas are written casually, like “AI thing for studying” or “Uber for X.” The Idea Expander turns the rough idea into aliases, adjacent categories, competitor terms, failure phrases, and meanings to avoid.

Agent 2 - Research Scout

The Research Scout searches across places where project history usually lives: Devpost, GitHub, Product Hunt, Hacker News, Reddit, IndieHackers, Medium, startup pages, and public postmortems. It returns normalized evidence with titles, URLs, years, domains, source types, snippets, and relevance scores.

Agent 3 - Historian

The Historian turns the evidence into a timeline of past attempts. For each attempt, it explains what was built, what worked, what failed, what was missing, and what lesson a new team should learn.

Agent 4 - Landscape Agent

The Landscape Agent focuses on what is still alive. It finds current competitors, what they do, why they matter, and what weaknesses still exist.

Agent 5 - Pattern Agent

The Pattern Agent uses Backboard memory to find semantically related ideas from previous searches. Then it identifies repeated failure patterns across those related ideas and compresses the insight into the main “turn” of the story.

Agent 6 - Synthesis Agent

The Synthesis Agent takes the timeline, competitors, failure pattern, and source quality summary, then produces the final opportunity gap and timing insight.

Agent 7 - Builder Agent

The Builder Agent runs when the user wants to turn the research into a plan. It creates positioning, MVP features, mistakes to avoid, risks, mitigations, and the next three steps.

The Architecture

┌──────────────────────────────────────────────────────────────────────┐
│                              User Layer                              │
│                                                                      │
│   Browser Client                                                     │
│   - Enter a hackathon idea                                           │
│   - Watch Scout research the idea                                    │
│   - Experience the three-act narrative reveal                        │
│   - Open the notebook view                                           │
│   - Explore prior attempts                                           │
│   - Generate a build plan                                            │
└──────────────────────────────────────────────────────────────────────┘
                                │
                                ▼
┌──────────────────────────────────────────────────────────────────────┐
│                            Express API                               │
│                                                                      │
│   POST /api/search                                                   │
│   - Runs the full Scout research pipeline                            │
│   - Creates a structured result envelope                             │
│   - Applies retries, timeouts, and validation                         │
│   - Saves completed searches into Backboard memory                    │
│                                                                      │
│   POST /api/build                                                    │
│   - Runs the Builder Agent                                           │
│   - Turns the research bundle into a practical build plan             │
│                                                                      │
│   GET /api/graph/stats                                               │
│   - Reads Backboard memory stats                                     │
│   - Returns total ideas searched and recurring patterns               │
└──────────────────────────────────────────────────────────────────────┘
                                │
                                ▼
┌──────────────────────────────────────────────────────────────────────┐
│                    Backboard + Gemini Agent Pipeline                  │
│                                                                      │
│   Agent 1: Idea Expander                                             │
│   - Rough idea → aliases, categories, competitor terms                │
│                                                                      │
│   Agent 2: Research Scout                                            │
│   - Grounded Gemini search across public sources                      │
│   - Returns normalized evidence with stable source IDs                │
│                                                                      │
│   Agent 3: Historian                                                 │
│   - Evidence → chronological story of previous attempts               │
│                                                                      │
│   Agent 4: Landscape Agent                                           │
│   - Finds active competitors and their weaknesses                     │
│                                                                      │
│   Agent 5: Pattern Agent                                             │
│   - Searches Backboard memory for adjacent ideas                      │
│   - Finds recurring failure patterns                                 │
│                                                                      │
│   Agent 6: Synthesis Agent                                           │
│   - Produces the gap and timing insight                              │
│                                                                      │
│   Agent 7: Builder Agent                                             │
│   - Turns the archive into an MVP plan                               │
└──────────────────────────────────────────────────────────────────────┘
                                │
                                ▼
┌──────────────────────────────────────────────────────────────────────┐
│                       Backboard Memory Graph                          │
│                                                                      │
│   Every completed search is saved as memory                           │
│   - Idea text                                                         │
│   - Failure signals                                                   │
│   - Turn sentence                                                     │
│   - Competitors                                                       │
│   - Source domains                                                    │
│   - Research quality                                                  │
│                                                                      │
│   New searches use semantic recall to find adjacent ideas              │
│   and improve pattern detection over time.                            │
└──────────────────────────────────────────────────────────────────────┘
                                │
                                ▼
┌──────────────────────────────────────────────────────────────────────┐
│                       Frontend Story Layer                            │
│                                                                      │
│   Three-act reveal                                                    │
│   - Past attempts                                                     │
│   - What happened to each one                                         │
│   - The recurring pattern                                             │
│   - Living competitors                                                │
│   - The remaining gap                                                 │
│   - The user's own idea                                               │
│                                                                      │
│   Notebook view                                                       │
│   - Each prior attempt becomes a page                                 │
│   - Users can inspect lessons and sources                             │
│   - Builder page turns the story into a plan                          │
└──────────────────────────────────────────────────────────────────────┘

Data flow

User enters an idea.
Idea Expander creates better search angles.
Research Scout finds public evidence with Gemini grounding.
Scout normalizes and deduplicates sources.
Historian builds a timeline of previous attempts.
Landscape Agent finds current competitors.
Pattern Agent searches Backboard memory for related ideas.
Synthesis Agent creates the gap and timing insight.
Scout saves the completed result into Backboard memory.
Frontend reveals the story.
Builder Agent can generate a practical build plan.

How we built it

Layer	Technology
Frontend	React 18 + Vite
Routing	React Router
Styling	Tailwind CSS
Backend	Node.js + Express
AI Orchestration	Backboard.io
AI Agents	Seven-agent Backboard pipeline
LLM	Google Gemini 2.0 Flash
Search Grounding	Gemini with Google Search grounding
Memory	Backboard persistent memory graph
Recall	Backboard semantic memory search
Data Format	Structured JSON contracts
State	React Context + sessionStorage
Reliability	Retries, timeouts, validation, fallback states
UI Concept	Three-act narrative reveal + notebook view

Challenges we ran into

One of the biggest challenges was keeping the agent outputs consistent. Each agent depended on the previous one. If the Idea Expander returned messy search terms, the Research Scout got worse results. If the Research Scout returned weak sources, the Historian had less to work with. If source IDs were inconsistent, the final story could not cite evidence properly.

We solved this by giving each agent a strict JSON shape and adding validation between every stage.

Another challenge was grounding. Scout only works if the history feels real. We had to be careful about hallucinated links, vague claims, and weak evidence. To fix this, we used Gemini with Google Search grounding for research-heavy stages, added URL validation, and forced downstream agents to work from source IDs instead of making unsupported claims.

Backboard memory also took iteration. At first, memory entries were too freeform. The Pattern Agent could not reliably compare past searches. We fixed that by storing structured metadata for each idea, including failure signals, source domains, competitors, and the final turn sentence.

The frontend was also a challenge because we did not want Scout to feel like a normal dashboard. We had to design the timing of the reveal carefully. The pauses, order, and pacing mattered because the project was about storytelling, not just information retrieval.

Accomplishments that we're proud of

Built a seven-agent research pipeline using Backboard
Used Backboard as an AI operating system, not just a chatbot wrapper
Used Gemini as the reasoning layer across Scout
Used Gemini with Google Search grounding for public evidence
Built persistent idea memory using Backboard’s memory graph
Used semantic recall to compare new ideas against past searches
Created a recurring failure-pattern engine for hackathon ideas
Built a stable source system for grounded claims
Turned raw research into a three-act narrative reveal
Built a notebook interface for exploring previous attempts
Created an on-demand Builder Agent for MVP planning
Added validation, retries, timeouts, and fallback states

What we learned

We learned that Backboard is most powerful when it is used as infrastructure, not just as a wrapper around a model. Splitting Scout into focused agents made the system easier to build, debug, and improve.

We also learned that memory changes the product. Without memory, Scout is a one-time research tool. With Backboard memory, every search makes the next search smarter. The product becomes a growing archive of idea histories.

Gemini’s grounding was also important. Scout depends on real-world evidence, and Gemini with search grounding helped us connect the story to actual public sources instead of unsupported guesses.

The biggest design lesson was that information becomes more powerful when it has pacing. The same research could have been shown as a table, but the story format made people feel the weight of past attempts before thinking about their own idea.

Technology should not just answer the question. It should help you understand the story behind it.