IdeaForge

Landing page
Join shared board
Dashboard
Board view
Personalize board
Customize board style
Organize ideas into clusters
relationship suggestion
Board assistant
Assistant's idea
Conclusion board's ideas
QR code share

Github Link

Inspiration

Every hackathon starts the same way for us. Four people throw ideas into a group chat or onto a shared whiteboard, and soon there are dozens of notes and no plan. Some of the best ideas are halves of something bigger. One person has the right audience and another has the right mechanism, but nobody notices because their notes sit on opposite sides of the board. When the team finally settles on a concept, nobody can say where it came from or whose idea it built on.

Before writing any code, we looked at what already exists. Miro AI already generates, clusters, and summarizes sticky notes, so clustering alone wasn't worth building. We also gave three Gemini models the same two notes and asked them to combine them. All three proposed the same obvious combination, which is what any chat assistant would give you. A merge button wasn't enough either. What teams need help with is spotting which pair to combine on a crowded board, especially pairs from different themes and different people, and keeping a record of who contributed what.

IdeaForge is our attempt at that. We built it in one week for Forgehack, in the AI + Creativity / Collaboration track.

What it does

IdeaForge is a shared canvas where a team finds which of its ideas are worth combining, merges them into new concepts, and keeps the history of each one.

A team opens a board link and adds idea notes. A new board starts with five AI-generated starter ideas based on its title and description, so nobody has to start from an empty canvas. People can link two notes as Works well together, Conflicts with, or Extends. A conflict link has to state the condition under which the two ideas can't both hold.

Organize groups notes by embedding similarity, arranges them on the canvas, and suggests a name for each group. In the background, Suggested Links proposes up to three links at a time from anywhere on the board, including pairs from different groups. A suggestion stays a preview until someone accepts it.

When you select 2 to 8 notes, IdeaForge drafts a merge preview you can edit. It has a title, a concept, and one distinct contribution from each source. It also names the shared mechanism, the tension between the ideas, the assumptions the concept adds, and a next experiment the team could run. If a selected note would weaken the concept, the AI leaves it out and gives a reason. Keeping the preview creates a new note that stores its parents, their authors, and a snapshot of the source text. The original notes don't change.

Participants upvote ideas, and Top ideas ranks them by votes. Votes show what people like, but they don't decide anything. To wrap up, the team selects the ideas and groups that matter and generates a board conclusion. It lists themes, key ideas with their authors, open questions, and next steps. Each theme, key idea, and open question cites the notes it draws on. The team can edit the conclusion, keep it, and export it as Markdown.

Boards sync live. They have presence, cursors, cursor chat, reactions, freehand drawing, undo and redo, PNG export, and QR sharing. You can try the app at idea-forge-wine.vercel.app/try, a sandbox board that doesn't need an account and saves nothing.

How we built it

The app runs on Next.js with the App Router, React, and TypeScript. The canvas uses React Flow, with custom nodes for notes and custom edges for links and ancestry. Liveblocks handles real-time sync, presence, and room storage. Better Auth and MongoDB handle accounts, the dashboard, and board metadata. The canvas document lives only in Liveblocks, and MongoDB stores a pointer to each room. One set of Zod schemas validates every request and every AI response.

The AI work is split across three providers:

Job	Provider
Merges, group names, conclusions, the assistant, starter ideas	GLM-5.3-Flash on Featherless
Similarity for Organize	`gemini-embedding-001`
Relationship classification for Suggested Links	Jev on TypeSafe

Every AI call goes through one server-only module. If a provider is overloaded or times out, the module retries once and then falls back to a second model. It validates each reply with Zod, and its errors name the cause. Provider keys stay on the server.

The four of us split the work into four roles: canvas interactions, deployment and sync, embeddings and similarity, and the AI module and prompts. We kept a decision log from the first day. Every change to scope or architecture got a dated entry explaining why we made it. We tracked tasks in the repo, and each one records how it was verified. The app was deployed and verified on Vercel by day two.

Challenges we ran into

At first, similarity scores told us almost nothing. To an embedding model, short notes on the same board goal all look alike. In a nine-note test, every pair scored between 0.66 and 0.93, and an unrelated pair scored the same as a related one (0.80). Subtracting the board's mean embedding before comparing fixed this, and the same two pairs moved to 0.21 and −0.04. We also found that similarity misses stance. A note arguing against gamification scored the same against "short daily challenges" as an unrelated note did. For that reason, closeness on the canvas never creates a link in IdeaForge, and the link type always comes from a model that reads the text.

Getting structured output took more work than we expected. For GLM-5.3-Flash, Featherless ignored JSON mode, JSON schema constraints, guided decoding, and forced tool calls, so only the prompt kept the model in JSON. In early tests, 5 of 16 assistant greetings came back as plain prose. We rebuilt the parser so it pulls one JSON object out of any surrounding text and tolerates small format slips. When a reply still fails, we send it back to the model once with the specific problem. After those changes, 8 of 8 greetings and 17 of 18 action-heavy prompts succeeded.

We benchmarked before choosing a model. Twelve Featherless models each ran the merge, assistant, and naming routes 22 times. Some timed out. One answered English greetings in Vietnamese and used only 2 or 3 of the 8 notes in a merge. Others put their answer in a field the app doesn't read. GLM-5.3-Flash and DeepSeek-V4.1-Flash finished close together. GLM was faster at the median (3.4 seconds against 5.5) and cost about half as much. We made GLM the default and DeepSeek the fallback.

Forcing every selected note into a merge produced weak concepts. We changed the rules so the model can leave a note out with a reason, as long as at least two notes contribute. In a live run of 30 merges of eight notes each, 27 returned a useful proposal that left out 2 to 5 notes.

Collaboration brought its own problems. Someone can edit a source note while a merge preview is open. When that happens, the app won't keep the stale preview and asks you to regenerate it. Links also have to stay readable while people drag cards around. We wrote an orthogonal link router with port spacing, lane separation, and bridges where links cross.

On the first day, a team brief proposed rebuilding on Vite, Express, Socket.IO, and Render. We kept the existing stack. Liveblocks already handled reconnection, persistence, and concurrent edits, and Socket.IO would have made us build those ourselves. Later in the week, we moved our separate Express account service into Next.js route handlers, so we only deploy one app.

Accomplishments that we're proud of

You can trace any merged note back to the people whose ideas it came from. It records its parents, their authors, and the exact text it used, and that record stays intact when someone edits a source later.

The AI makes proposals, and people decide what to keep. Suggested links, merges, and conclusions all start as previews, and only a person can save one. When a connection is weak, the AI is required to say so.

We based our main technical choices on benchmarks we ran ourselves: the generation model, the similarity method, and the relationship classifier. The numbers are in our decision log.

We checked each step of the journey against real providers and live Liveblocks rooms: creating a board, adding ideas, organizing, linking, merging, voting, and concluding. The test suite has 195 tests, and lint, typecheck, and the production build all pass.

Anyone can try IdeaForge without an account or API keys through the /try sandbox.

What we learned

Embeddings tell you whether two notes share a topic. They can't tell you whether the notes agree, because two notes can be close precisely because they argue about the same thing. When the type of relationship matters, a model has to read the text.

We now test a provider's structured-output settings before relying on them. Validating every reply and giving the model one chance to fix its mistake took the assistant from 5 failures in 16 greetings to 8 successes in 8.

Most of our time went into collaboration problems, not model calls: stale previews, concurrent edits, attribution, and making sure a suggestion never becomes a decision without someone choosing it.

The decision log helped a four-person team moving fast. When a question came up again, we could point to the dated entry and the reasoning behind it.

What's next for IdeaForge

Access control. Right now anyone with a board link can edit the board. We want invitations, roles, and permission changes.
A full AI evaluation. We have human-labeled note pairs and a classifier benchmark. Next we want blind comparisons between IdeaForge merges and a plain "combine these notes" prompt, plus similarity checks on larger real boards.
Sessions with teams who haven't seen the app before. We want to find out whether IdeaForge actually helps people turn scattered ideas into a concept they want to build. So far that's a hypothesis, not a measured result.
Finishing and verifying the board assistant, a chat sidebar that proposes create, edit, link, and merge actions as previews.
Smaller classification batches for Suggested Links. In our benchmark, both classifiers missed most links that came late in a large batch.
Later, we may add retrieval over uploaded documents, and critic personas clearly labeled as simulated feedback.