# Ideator: an agent that tells you what to build, not just what exists

> Source: <https://dev.to/ronaksarda/ideator-an-agent-that-tells-you-what-to-build-not-just-what-exists-38o0>
> Published: 2026-10-18 06:04:46+00:00

*This is a submission for the [Hacktoberfest Open-Source AI Challenge Week 2: Side Hustle](https://dev.to/challenges/hacktoberfest-week2-2026-10-12).*

**Ideator** checks a startup idea against the real market and walks you to a decision.

You type your idea in one line. Ideator searches Google, Google Play and Reddit, puts every competitor, price, feature and user complaint into a graph, and a Gemma agent works through that graph until it can tell you, with sources, what to build.

**The problem.** Founders validate ideas with twenty browser tabs, a few app store pages, some Reddit threads and a gut feeling. They come out with a list of competitors and no decision. Chat assistants don't fix this: ask one about your idea and you get a confident feature list, ask again and you get a different one. After ten messages you still don't know who pays, what to charge, or what version 1 is.

**What Ideator gives you instead.** Every reply ends with a five-slot build brief:

| Slot | What it means | 
|---|---|
| Who pays | the exact paying segment | 
| Pain you fix | the one complaint you fix, with how many users raised it | 
| Why you beat them | the edge over the named competitors | 
| Price | a USD price with its reason (from a TabPFN model) | 
| First version | the 2-3 things v1 ships, and nothing else | 

The evidence fills the pain and the price on the first turn. The other three are your call, so Ideator asks for them one at a time, each with a suggestion taken from the evidence. A few turns later you have a full brief, and the Action plan tab gives you the plan in one paragraph and a numbered build order. Every user quote links to its source. You can also export the plan as an `AGENTS.md` file and drop it into Claude Code or Cursor, so your coding agent starts from decisions instead of a blank prompt.

**Who would pay for it:**

Ideator is an agent that checks a startup idea against the real market. You describe an idea. It finds companies with a similar product, what they offer and charge, and what their users complain about. All of that goes into a FalkorDB graph. A Gemma-powered agent then works through the graph with MCP tools, decides where the opening is and saves that decision in the graph, linked to the evidence behind it.

Demo video: [Ideator](https://youtu.be/BAruAQ9rAyY)

`MERGE` queries, in one graph per user session. Features that share a meaningful…
**Open-source AI at the core:**

`gemma-4-26b-a4b-it`, then `gemma-4-31b-it`), open-weight, runs the agent loop and writes the report. When the hosted endpoint fails, short prompts fall back to `gemma2:2b` on a local `market_history` graph, and the `predict_price` tool trains a TabPFN regressor on that history at call time. The more the app is used, the better the price estimates get. A second tool feeds graph counts into a TabPFN classifier to score how crowded the market is.
**How a request flows:**

`Decision` node with `BECAUSE` edges to the complaints and features behind it. On the map you can click the decision and follow the edges back to the original Reddit post.
The query that does most of the work finds what users of several competitors complain about that your idea doesn't fix yet:

``` php
MATCH (u:UserIdea {id: $idea})-[:TARGETS]->(c:Competitor)-[:DRAWS_COMPLAINT]->(g:Grievance)-[:TARGETS_FEATURE]->(f:Feature)
WHERE NOT (u)-[:SOLVES]->(g)
RETURN f.name, count(DISTINCT g), collect(DISTINCT c.name)
ORDER BY count(DISTINCT g) DESC
```

When you refine the idea, the new version gets `SOLVES` edges, so the same query moves on to the next unmet need.

**Around it:**

**What went wrong, and what I changed:**

`REQUIRED` in `tools.py`): the agent cannot finish until both tools have run.
A founder's unannounced idea is sensitive. Open weights mean the model that reads it does not have to be a black box you rent. Ideator already falls back to a local Gemma through Ollama, and the graph database and the tool server run on your own machine. Search is the exception today: queries go to SerpApi, and price predictions go through Prior Labs. Fully local is the direction. It is not where Ideator is yet.

Open weights also kept the product alive. The hosted Gemma endpoint returned errors more than once during the build. Because the model is open, I could fall back to a local Gemma and keep answering instead of showing an error page.

And the parts I needed most were already open: PageRank and community detection are built into FalkorDB, TabPFN trains on my own collected data in one call, and MCP let me expose the graph as tools without inventing a protocol. With closed tools I would have spent the week on glue instead of on the product.

My first users were a few friends from college. They tried Ideator on my machine with their own ideas, and they liked it enough to say they would pay about ₹2,500 each to use it. No money has changed hands yet.

I told them it is open source and BYOK (bring your own key), so they can run it themselves for free. Their answer was "then publish it": put it online with a login page and a paywall, and charge for it. That is the side hustle, and it is my next step.

The best feedback was what happened next. One friend was inspired by Ideator and, after running their own idea through it, started a project of their own: **Praesentia**, an ERP agent for our college that handles marks, courses and a lot more.

`search_more_complaints` tool lets it run another live search mid-analysis.
I built Ideator with help from AI coding assistants, including Claude Code and Google Antigravity. I reviewed, ran and tested the code, and I can explain the graph model, the queries and the architecture.