OnboardX: The Ghost of Community Knowledge Shouldn’t Disappear

This is a submission for the Hacktoberfest Open-Source AI Challenge: Week 4 — Ghost in the Machine.

What I Built

When student community leaders leave, what happens to everything they learned?

There might be a handover document somewhere. Some explanations are buried in chats. Other things only exist in someone’s head: why a venue was chosen, what went wrong during a workshop, or which project the next team should continue.

As someone involved in student communities at FUTMinna, this is a problem I care about. The next team should have something useful to build on.

I built OnboardX, a local community memory and handover app. It lets you save decisions, lessons and unfinished work, ask questions about those records, and generate an editable handover draft.

My Interpretation of “Ghost in the Machine”

I approached the theme through the knowledge previous teams leave behind.

A former lead might have moved on, but their documented experience can still help the next person make a decision. OnboardX makes those records easier to find and use.

It doesn’t impersonate previous leaders. It answers from what they recorded and shows the source.

Demo

Repository: https://github.com/ufidscript/onboardx

Demo video: https://www.youtube.com/watch?v=lp8-wIt36VM

The app includes a fictional sample community so people can explore it without needing private community documents.

The main journey is:

1. Save a memory with a title, category and content.
2. Ask a question about the archive.
3. Read the answer alongside its supporting excerpts.
4. Generate a handover draft, review it and export Markdown.

One question I tested was:

Why did we choose the library?

OnboardX answered that the library had reliable power and seating. Under the answer, it showed the saved “Workshop venue decision” record containing that explanation.

I also asked for the president’s phone number, which wasn’t in the records. It responded:

I couldn't find that in the saved records.

That second result matters to me. A handover tool needs to make gaps visible, because the next team might act on what it says.

How It Works

The frontend uses React and Vite, with an Express backend and a local JSON file for persistence.

Saved memories are split into smaller excerpts. When someone asks a question, lightweight keyword retrieval selects relevant excerpts and passes them to Gemma 3 1B through Ollama.

The model produces a structured JSON response. The backend checks its format and citation IDs, then resolves those IDs to the stored excerpts shown in the interface.

This helps keep references tied to actual records. It doesn’t guarantee that every generated sentence is correct, so the original text remains available for inspection.

The handover feature uses the archive to draft sections covering context, decisions, lessons, unfinished work and gaps. Users can edit the draft before exporting it.

Prize Categories

Best Use of Gemma

OnboardX uses Gemma 3 1B locally through Ollama to answer questions using retrieved community records and generate editable handover drafts. Gemma powers the core AI features while keeping inference on the user’s machine.

Best Use of GitHub Copilot

I used the GitHub Copilot app to build and debug OnboardX incrementally, including the React interface, Express endpoints, retrieval, citation validation and handover export. I guided the implementation and manually tested the application locally.

Why Open Innovation Matters Here

Community handover records can contain internal discussions and decisions. I wanted a version that could run with the records and model on the same machine.

Using an open-weight model through Ollama makes local inference possible. The core workflow doesn’t require a hosted AI API, and the model can be changed through configuration.

There are still setup requirements: users need to install the dependencies, Ollama and the model. Local inference also uses the laptop’s resources. But there is no per-request hosted AI charge for this setup.

For a tool intended to preserve knowledge, being able to keep and run the system yourself is part of its value.

Building It—and Learning Along the Way

I built with the GitHub Copilot app and tested the results locally.

Getting the app running took some debugging. Node wasn’t initially available in my terminal. After installing it, I ran into missing dependencies, then opened the backend address expecting to see the frontend and got Cannot GET /.

Working through those steps helped me understand the separate jobs of the React development server and the Express API.

Testing also exposed a more meaningful issue: an unanswered question could still display an unrelated retrieved record under “Sources.” That made the distinction between retrieved text and supporting evidence very clear. Finding a record does not mean it supports the answer.

The most satisfying moment was seeing a question answered with the exact saved explanation underneath it. That made the idea feel useful beyond being another chat interface.

Current Limitations

This is a local prototype with a focused scope:

• It has no accounts or shared online workspace.
• Keyword retrieval can miss relevant records when questions use different wording.
• Gemma 3 1B can make mistakes.
• Generated handovers need human review.
• Markdown export creates a readable handover; it doesn’t automatically transfer the searchable archive to another device.

I’d like to improve retrieval and archive portability next. For this version, my priority was a working path from saving knowledge to asking about it and preparing a handover.

AI Assistance Disclosure

I used GitHub Copilot to assist with implementation and debugging, and ChatGPT to help with planning and this write-up. I directed the work and manually tested the local application. This was an AI-assisted build.

If you’ve ever taken over a student community or team, what was the one thing you wish the previous leaders had written down?