Every roadmap tool ever made shares one quiet assumption: that you arrive already knowing what to build. The board is waiting, the columns are empty, and the very first thing it asks of you is the hardest thing in the whole endeavor — what should go on here? Threlmark answers “of everything on my roadmap, what’s most important to do next.” But there’s an earlier, more uncomfortable question that sits upstream of it: what should even be on the roadmap in the first place? IdeaClyst is built to answer that one.

IdeaClyst is an idea engine. It turns rough product concepts into concrete, founder-ready plans, it scouts the web for real opportunities, and — most usefully — it reads a roadmap you’re already keeping, sees where it’s thin, and proposes specific, scored work to fill the gaps. It’s the companion to Threlmark, and where Threlmark is the command deck that helps you execute a roadmap, IdeaClyst is the engine that helps you populate one with work worth doing. This piece is about that engine on its own terms; a later article covers the two working as one closed loop.

The problem nobody admits: ideation doesn’t scale by willpower

If you build a lot, you know the failure mode. It isn’t that you run out of tasks — there’s always more to do. It’s that you run out of good, validated, well-aimed ideas, and the ones you do generate tend to come from the same few grooves your brain already runs in. You build what’s top of mind, not what’s most valuable. You miss the adjacent product hiding in plain sight. You re-discover, three months late, that a competitor shipped the obvious thing while you were polishing something nobody asked for.

The honest truth is that ideation is real work, and it’s the work most likely to get skipped under pressure, because it has no deadline and produces nothing shippable on the day you do it. So it gets deferred, and the roadmap quietly fills with whatever was easiest to think of. IdeaClyst exists because that’s a tooling gap, not a character flaw — and tooling gaps can be closed.

How it generates: a Claude–Codex council

The core of IdeaClyst is not a single model prompt. It’s a council — Claude and Codex working together rather than a lone model answering in one pass. That structure matters more than it might sound. A single model generating ideas tends to produce a confident, plausible, and slightly generic list. A council — models proposing, critiquing, and refining against each other — surfaces the disagreements, catches the weak ideas that sound good, and pushes the survivors toward something sharper. It’s the difference between brainstorming alone and brainstorming with a sharp colleague who isn’t afraid to say “that one’s obvious, dig deeper.”

On top of that council, IdeaClyst scouts the web for opportunities. Ideas generated in a vacuum are just guesses; ideas grounded in what’s actually happening in a market are proposals. So the engine researches — the landscape, the competitors, the adjacent moves — and uses that to anchor what it suggests. The output isn’t “here are some things you could do.” It’s “here is specific work, aimed at a real gap, with the research that justifies it attached.”

How it aims: reading your roadmap and mapping the gaps

This is the part that turns a generic idea generator into something genuinely useful, and it depends entirely on Threlmark keeping its data in the open. Because a Threlmark roadmap is just plain files on disk that any tool can read, IdeaClyst can do something most idea tools can’t: it can look at what you’re actually building before it proposes anything.

It reads a project’s roadmap read-only — listing the projects, reading the items and the board, computing the very same priority score Threlmark uses — and from that it builds a deterministic gap map. The gap map is exactly what it sounds like: a structured picture of where your roadmap is thin. Which categories are well-covered and which are barely touched. How many items sit in each lane. Where the under-covered areas are. It’s deterministic on purpose — the same roadmap always yields the same gap map, so the analysis is something you can trust and re-run rather than a different mood each time.

The point of the gap map is that it makes the suggestions targeted rather than scattershot. IdeaClyst isn’t proposing random good ideas; it’s proposing the ideas that fill the specific holes in the roadmap you already have. If your “Distribution” category is empty while “Build” is overflowing, that’s exactly what the gap map sees, and exactly what the proposals respond to.

What it proposes: Features, Spin-offs, Services

IdeaClyst ships all of this as a capability called Roadmap Intelligence. You pick a Threlmark project, and three research lanes go to work against the gap map and live web research — each one a different kind of opportunity, because the most valuable next move isn’t always another feature.

The first lane is Features: concrete additions to the product you’re already building — the things that fill functional gaps in the existing roadmap. The second is Spin-offs: possible separate products adjacent to what you have, the new thing hiding inside the current one that you’d never have stopped to notice. The third is Services: offerings you could provide around the product — the revenue and value that isn’t a software feature at all. Splitting proposals across these three lanes is a quietly important design choice, because founders systematically over-index on features and under-explore the other two. By making spin-offs and services first-class outputs, IdeaClyst widens the aperture past “what else can I add to the app” toward “what’s the most valuable thing I could do next, of any kind.”

Each proposal arrives scored — on the same impact/evidence/fit/effort axes Threlmark ranks by, so a suggestion lands ready to slot directly into a prioritized backlog — and backed by research, carrying its provenance with it: what kind of opportunity it is, the rationale for why it’s worth doing, and the sources behind it. A proposal isn’t a one-line “you should build X.” It’s a small, defensible case: here’s the work, here’s why, here’s the evidence, here’s how important it scores.

Where they land: the Inbox, and your final say

IdeaClyst never reaches into your roadmap and rearranges it. It does exactly one write: it drops its scored proposals into the project’s Inbox, and then it stops. What happens next is entirely your call. You glance at each suggestion and either Accept it — at which point it becomes a ranked item on your board, ready to prioritize and eventually hand to an AI agent to build — or you Dismiss it. And if a suggestion is good but aimed at the wrong project, you can route it into a different one where it fits better.

That division of labor is the whole philosophy in one gesture. The engine does the tireless, research-heavy, easy-to-skip work of generating and aiming and justifying. The human does the irreplaceable work of judgment — deciding what actually matters, what fits the vision, what to commit to. IdeaClyst proposes; you dispose. It’s an idea engine, deliberately not an autopilot, and the Inbox is where that boundary lives. You are never handed a roadmap someone else decided; you’re handed a stack of well-argued options and asked to choose.

Why the open contract is the thing that makes it possible

It’s worth being clear about why IdeaClyst can do any of this, because it isn’t magic — it’s architecture. IdeaClyst can read your roadmap and write proposals into it only because Threlmark keeps everything as plain, open files that any tool is free to read and write. There’s no API to be granted access to, no account to connect, no permission to request. IdeaClyst added a small layer that speaks Threlmark’s exact file shapes, and that was enough to participate fully.

The consequence reaches past IdeaClyst itself. Because the contract is open, any tool can do what IdeaClyst does — read a roadmap, understand its gaps, and drop scored suggestions into the Inbox the same way. IdeaClyst is the first and most complete example of an idea engine plugging into that contract, but it’s an example, not a gatekeeper. The roadmap is yours, the data is open, and the engines that feed it are interchangeable. That’s a very different posture from a closed suite where the idea feature and the execution tool are welded together and you take both or neither.

The shape of it

Strip IdeaClyst down to its essence and it’s a simple, powerful inversion. Most tools wait for you to know what to build. IdeaClyst does the upstream work — generating ideas through a Claude–Codex council, grounding them in live web research, aiming them at the real gaps in a roadmap it can actually read, splitting them across features, spin-offs, and services, scoring each one, and attaching the evidence — and then it hands the results to you as proposals in an Inbox, where your judgment makes the final call.

It closes the gap that pressure always opens: the one where ideation gets skipped because it has no deadline, and the roadmap fills with whatever was easiest to think of. With an engine doing the tireless part, the bar for what lands on your roadmap rises, because the candidate work arriving in your Inbox is researched, aimed, and scored rather than improvised. You still decide everything that matters. You just decide it from a much better menu.

And once those accepted proposals become ranked work on a Threlmark board — ready to hand to an AI agent that builds them and reports back — the full circle comes into view: ideas in, finished work out, with you making the calls at every step. That complete loop is the subject of the next piece. This one is just the engine that starts it.

IdeaClyst is a companion to Threlmark. Learn more at threlmark.com.

© 2026 · Thorsten Meyer · Powered by Thorsten Meyer AI