Inspiration
AI has made it dramatically easier for a solo developer or small game team to generate ideas, code, mechanics, lore, and design alternatives.
But while building my own game projects, I kept running into the opposite problem: the faster AI helped me create things, the harder it became to know what was actually true.
Design intent lived in Markdown. Decisions were buried in conversations. Implementation reality lived in Git and Unity. AI could confidently suggest something that had already been rejected, contradict an earlier decision, or describe a feature that did not actually exist.
I built ForgeMind around a simple question:
How can game developers use AI aggressively without letting temporary AI output silently become project truth?
That became the core model:
INTENT ↔ REALITY ↔ ALIGNMENT
What it does
ForgeMind is a local-first AI workspace for game development.
It creates a source-aware Project Brain that connects reviewed design knowledge, decisions, unresolved questions, AI conversations, external research, and read-only implementation evidence.
One of the core workflows starts with documentation a developer already has.
I can import an existing Markdown design document. NVIDIA Nemotron, running through Nebius Token Factory, extracts structured candidates such as:
- Project Knowledge
- Proposed Decisions
- Open Questions
Nothing becomes truth automatically.
I can review, edit, reject, and explicitly apply only the candidates I want to keep.
Once applied, the Game Wiki updates immediately while preserving provenance: where the information came from, that AI assisted with extraction, and that a human reviewed and applied it.
The Writers’ Room then reasons over that updated Project Brain instead of starting from a blank chat. Its responses include visible source traces, so I can see which established project knowledge supported an answer.
When outside inspiration is useful, I can explicitly research the web with Tavily. Those sources remain clearly marked as EXTERNAL_RESEARCH and separate from established project knowledge. Nemotron can compare them with the current game direction without automatically turning research into canon.
ForgeMind can also read bounded evidence from Git and Unity and compare implementation reality against design intent, making alignment, uncertainty, drift, and conflict visible.
The central rule is:
AI can extract, research, compare, and propose. Humans decide what becomes project truth.
How I built it
ForgeMind is a desktop application built with Tauri 2, Rust, React, TypeScript, and Vite.
I used Nebius Token Factory as the inference provider and NVIDIA Nemotron 3 Super 120B A12B as the default model for ForgeMind's verified structured-output workflows.
The provider boundary lives in native Rust. API credentials remain native-only and are not stored inside ForgeMind project data.
I also integrated Token Factory's model catalog. ForgeMind deliberately separates:
provider availability ≠ verified application capability
A model appearing in Token Factory does not automatically make it eligible for a structured workflow. Unknown and custom models remain unverified until the application explicitly knows that the required capability is supported.
For external research, I integrated Tavily Search directly into Writers’ Room. Research is explicit and human-selected rather than autonomous.
ForgeMind stores project state locally in bounded JSON stores. The Game Wiki itself is a derived view rather than another independent source of truth.
I built the project solo, using ChatGPT and OpenAI Codex extensively throughout architecture, implementation, testing, debugging, product design, security review, and documentation.
Challenges I ran into
One of the biggest lessons was that a successful model request is not the same thing as a valid product result.
During real Nemotron testing, I encountered responses that were valid JSON but violated local bounds, as well as several structured-output incompatibilities in Writers’ Room.
Instead of silently accepting partial results, ForgeMind fails closed. Invalid structured output cannot modify project truth.
Another challenge was designing provenance and authority correctly.
Imported Markdown is documented evidence, not automatically canon. A Decision extracted from a document begins as PROPOSED, not approved. Tavily research remains external research. AI conversations remain non-authoritative until a human explicitly applies a proposal through the owning domain.
I also had to solve desktop-specific security problems: native credential boundaries, path containment, symlink escape prevention, safe external URLs, public repository sanitization, and Tauri permissions.
Finally, research quality itself is imperfect. A Tavily search can technically succeed while returning sources that are only partially relevant. ForgeMind therefore lets the developer inspect and select research rather than automatically treating search results as trustworthy context.
Accomplishments I'm proud of
The part I am most proud of is the complete reviewed knowledge loop.
In the final Hollow Reach demo I can:
Markdown → Nemotron extraction → human review → Apply → Game Wiki → Writers’ Room
and the next AI request immediately reasons over the newly reviewed knowledge with visible source traces.
I can then add selected Tavily research and keep it visibly separate from established Project Brain knowledge.
I am also proud that ForgeMind does not hide uncertainty behind AI confidence. Decisions can remain proposed. Questions can remain unresolved. Models can be available but capability-unverified. Git and Unity evidence can disagree with intent.
Those states are part of the product rather than errors to conceal.
The public repository also went through a dedicated security and release audit before submission, including history sanitization, credential-boundary review, path-containment tests, and fresh-clone validation.
What I learned
Building ForgeMind changed how I think about AI-assisted development.
The difficult problem is increasingly not generating more content.
It is maintaining authority, provenance, context, and alignment as the amount of generated content grows.
I learned that model output becomes much more useful when the surrounding product is strict about:
- what context the model receives,
- where that context came from,
- what the model is allowed to propose,
- what must be validated,
- and which changes still require human authority.
I also learned that model capability should be evaluated at the task level. A model being available through a provider, or even successfully answering one request, does not prove that it can reliably satisfy every structured workflow.
What's next
After the hackathon, I want to continue developing ForgeMind as a broader AI workspace for real game-production workflows.
The next areas include richer design and narrative studios, better context retrieval, deeper implementation evidence, stronger alignment workflows, and more deliberate model evaluation and routing.
I also want to dogfood ForgeMind on a real long-running game project, where design intent and implementation naturally evolve over months rather than during a short demo.
The long-term goal remains the same:
help game developers move faster with AI without losing track of what is documented, what is decided, what is implemented, and what is still only an idea.
ForgeMind — Turn ideas into playable worlds.
