Project Info

Winner

GRAND PRIZE - Ddoski's World Track; Finalist

Lucid Voice

Inspiration

An estimated five million Americans and nearly a hundred million people worldwide cannot rely on their own voice, from ALS, stroke, autism, or cerebral palsy. The cruelest part of conditions like aphasia is that the person knows exactly what they want to say but cannot get the words out, and today's tools are slow and robotic. We wanted to build something that knows the person and gives them their own voice back.

What it does

Lucid Voice turns two or three tapped words into a full, natural sentence, spoken in a clone of the person's own voice. It is not autocomplete: it understands who they are talking to, so the same words become "sweetie" for a daughter and "mijo" for a grandson, and it learns their style the more they use it. Behind it is a personal "brain," a living model of their world that you can watch think, learn, and grow, and the whole thing runs on-device and offline so their private words never leave their hands.

How we built it

Lucid Voice is local-first. A personal knowledge graph (Kuzu) holds the person's people, routines, and preferences; a hybrid retrieval pipeline traverses that graph and uses a submodular optimization to pick the most relevant facts, which steer a frozen local model (Gemma via MLX on Apple Silicon) to write the candidates. Two learning systems sit on top: the graph reinforces associations the way memory does, and a style model learns the user's phrasing from which suggestions they pick, using the same preference formulation behind RLHF. Voice cloning (XTTS) and speech recognition (Whisper) run on-device too, with Redis for local vector search, Deepgram, Sentry, and Claude Code in the stack, and nothing on the core path touches the internet.

Challenges we ran into

On-device voice cloning sent us down a brutal dependency chain through torchaudio, torchcodec, and FFmpeg. Responses took sixty seconds until we found the model was burning thousands of reasoning tokens we then discarded, and turning that off made it near-instant. We also fixed a race that resurrected stale suggestions against the wrong line of conversation. The hardest part was conceptual: making the system truly understand the person rather than guess, and solving the empty-graph cold-start, which led to the mode where the assistant interviews the user to build their brain.

Accomplishments we're proud of

We built a complete real-time AI system, graph reasoning, generation, voice cloning, and speech recognition, that runs entirely on a laptop with the internet off, which is rare in a year when capable AI usually means a data center, and it keeps a vulnerable person's words private. We are proud that the context-awareness works, that the same input yields the right different sentence per person, and that the learning is real and visible on screen. And we kept the person in control by always proposing and letting them choose, never speaking for them.

What we learned

We went deep on running large models locally and fast, hybrid graph-and-vector retrieval, optimization, and preference learning. The bigger lesson was that sophistication only matters if people can see it, so we put the reasoning, learning, and growth on screen, and that preserving the user's agency and dignity matters more than any clever trick.

What's next

Richer automatic context like identifying who is speaking from their voice, more input methods such as eye-gaze and switch access for later-stage ALS, and real testing with the AAC and disability community and clinicians. Longer term, an opt-in cloud quality tier, deeper personalization as the brain grows, and getting it into the hands of the millions who could use it.

Speak again — in your own voice.

A local-first AAC app that turns 2–3 tapped words into a full, situationally‑correct sentence — spoken in a cloned version of the user's own voice.

The user's personal memory graph, rendered as a living brain. The exact memories that grounded a reply light up in real time.

What it is

People who can't speak fluently — after a stroke (aphasia), with ALS, or autism — communicate on tap‑boards at roughly 8 words per minute. Ordinary speech is about 150.

Lucid Voice closes that gap. The person taps a couple of word‑fragments; an AI reconstructs several full, register‑correct candidate sentences grounded in their personal life‑context; they select one, and it's spoken aloud in a clone of their own voice. Everything that matters runs on‑device, so it keeps working in airplane mode.

AAC = Augmentative & Alternative Communication.

The thesis — and the moat

The same minimal input produces a different, correctly‑registered reply depending on who is listening.

That's the whole idea, and it's the part a generic LLM prompt can't reliably do from two words:

She taps	Partner	Lucid Voice speaks
`tired · maybe`	Sofia (daughter)	"I'd love to, sweetie, but I've been so tired lately. Can I tell you Saturday?"
`tired · maybe`	Mateo (grandson, 4)	"I'm a little tired right now, mijo. Maybe after my nap? I love you."

Identical input. The wording, the term of endearment, even the promise of a nap — all pulled from a personal knowledge graph, not invented. The moat is the personal‑memory layer + on‑device privacy + the user's own preserved voice, not the text generation.

How it works

   ┌── Tap ──────────┐   ┌── Ground ─────────────┐   ┌── Reconstruct ───────┐   ┌── Speak ──────────┐
   │ 2–3 vocab tiles  │   │ Hybrid GraphRAG over   │   │ Claude writes 3       │   │ You select one →   │
   │ (or the partner's│ → │ your personal graph +  │ → │ register-correct      │ → │ it plays in your    │
   │ line via STT)    │   │ partner detection      │   │ candidates, grounded  │   │ cloned voice — and  │
   │                  │   │ → abstain if unsure    │   │ in your facts         │   │ the graph learns    │
   └──────────────────┘   └────────────────────────┘   └───────────────────────┘   └─────────────────────┘

Tap word‑fragments on a calm vocabulary board, or capture what the partner said with the mic (speech‑to‑text). Composition is tiles‑first — the assisted user never has to type (an optional type‑to‑add field is there if they want it).
Ground — retrieval.py runs a hybrid GraphRAG: anchor the fragments to graph nodes, detect who is being spoken to, expand the neighbourhood, blend in vector search, re‑rank, and select a low‑redundancy fact set. If confidence is too low it abstains ("add one more word") rather than guessing.
Reconstruct — generation.py asks the LLM for exactly three candidates at different lengths/registers, grounded in the retrieved facts. A learned personal style model re‑ranks them (server‑side) to sound like you, and a tone dial (warm / even / direct / playful) lets you nudge which register floats to the top.
Speak — selecting a candidate plays it aloud (cloned‑audio‑first, with an on‑device system‑voice fallback so it's never silent), fires /confirm, and reinforces the memory graph so it gets better over time.

Features

🧠 Personal Knowledge Graph (PKG) — an embedded Kuzu graph of the people, places, routines, preferences and phrases that make replies sound like you.
🎭 Register that fits the listener — partner detection drives the term of address ("sweetie" / "mijo" / "mi amor") and tone.
🗣️ Your own voice — zero‑shot voice cloning (Coqui XTTS‑v2), cache‑first so confirmed lines replay instantly and offline. Playback is cloned‑audio‑first; until a voice is enrolled it gracefully uses the best on‑device system voice.
🌀 Show your work — a 3D hologram‑brain view (/graph) where the retrieved memories fire the path that grounded each reply. Plus "Build your brain," where a warm AI interviews you and each answer blooms a new memory onto the graph, live.
📈 Online learning loop — every confirmation reinforces the graph; a consolidation pass promotes recurring patterns into durable preferences; and a scheduled decay pass (run_decay) fades what goes unused.
✈️ On‑device & airplane‑mode capable — local LLM, STT, TTS, embeddings and graph. Cloud providers are strictly opt‑in.

Architecture

 Frontend  (Vite · React · TypeScript · Tailwind · three.js)        :5173
 ├── Conversation  /        the unified turn-loop (capture → tap → generate → select → speak)
 └── Graph         /graph   the 3D hologram brain + "Build your brain"
        │  fetch /api/*  (Vite proxies /api → :8000)
 Backend   (FastAPI · Python)                                       :8000
 ├── retrieval.py   hybrid GraphRAG (anchor → expand → vector → rerank → submodular → abstain)
 ├── generation.py  LLM candidate generation (strict JSON, repair retry, fallback)
 ├── style.py       per-user learned communication-style model
 ├── graph.py       Personal Knowledge Graph (Kuzu)
 ├── learning.py    online learning (/confirm reinforce · /consolidate · decay)
 ├── cache.py       cache-first /speak (pre-rendered demo audio)
 └── providers/     local-first LLM · embedding · STT · TTS (cloud opt-in)

Every backend service is built lazily and degrades gracefully — the app boots and serves end‑to‑end even with no LLM / graph / TTS installed (returning correctly‑shaped placeholders), which is what makes it demo‑safe.

Tech stack

Layer	Default (on‑device)	Opt‑in cloud
LLM	LM Studio (OpenAI‑compatible, `:1234`)	Anthropic Claude
Embeddings	sentence‑transformers (`bge‑small`)	—
Speech‑to‑text	faster‑whisper	Deepgram
Voice clone / TTS	Coqui XTTS‑v2	ElevenLabs
Graph DB	Kuzu (embedded)	—

Cloud providers are reached only when you set their provider env var and supply an API key; with zero keys, everything runs locally.

API

/health · /generate · /speak · /confirm · /assistant_turn · /consolidate · /style/{person_id} · /stt · /enroll · /graph/{person_id} · /trace/latest

Quickstart

cd aac
./run.sh

run.sh creates/reuses a virtualenv, installs backend + frontend deps if needed, copies .env.example → .env, and starts both servers together.

Frontend: http://localhost:5173
Backend API: http://localhost:8000

Prerequisites

Python 3.10+ and Node 18+
FFmpeg — required by local voice synthesis (brew install ffmpeg). Without it, /speak still serves cached audio and degrades gracefully.
LM Studio serving any instruct model on :1234 — only needed for live (non‑DEMO_MODE) generation.

First run pulls heavy ML weights (XTTS‑v2 ≈ 1.8 GB); they cache after that. Or set DEMO_MODE=true in aac/backend/.env to skip all of it.

Manual run

# Backend
cd aac/backend && python3 -m venv .venv && source .venv/bin/activate
pip install -r requirements.txt && cp .env.example .env
uvicorn app.main:app --reload --port 8000

# Frontend (second terminal)
cd aac/frontend && npm install && npm run dev

Giving someone a cloned voice

cd aac/backend
python -m data.enroll_voice elena path/to/elena.wav   # a clean ~10s reference
python -m data.prerender_demo elena                   # pre-render demo lines into the cache

Project structure

aac/
├── backend/
│   ├── app/
│   │   ├── main.py            FastAPI app + endpoints + lazy DI
│   │   ├── services/          retrieval · generation · style · graph · learning · cache
│   │   └── providers/         llm · embedding · stt · tts (local-first, cloud opt-in)
│   └── data/                  seed_graph · enroll_voice · prerender_demo · fixtures
├── frontend/
│   └── src/
│       ├── views/             ConversationView (primary) · GraphView
│       ├── components/        HologramBrain · BuildBrainPanel · CandidateCard · VocabBoard · …
│       ├── hooks/useSpeak.ts  cloned-audio-first playback, browser-voice fallback
│       └── lib/               api · demo (offline fallback) · motion tokens
└── run.sh                     one-command dev launcher

Design language

Two characters, two colors: coral = the human (your words, your voice, your chosen sentence) and teal = the machine (its reasoning and state). A reading serif is reserved for the spoken human sentence; mono is the machine's instrument output. Calm, legible, AAC‑first — large targets, colour never the only signal, motion that conveys a transition rather than decoration, and reduced‑motion honored throughout.

Status

Built as a demo‑first hackathon project. Running today: the unified Conversation surface with a real speech‑to‑text turn‑loop, the 3D memory brain + "Build your brain," cloned‑voice playback (with a graceful browser‑voice fallback), and a polished, accessible UI.

Analysis

Compare with all teams

View

Metric

Figures cover GitHub contributors during the hackathon window. A co-authored commit counts in full for each author, so per-member totals add up to more than the whole-team figures.

Technology

Found in codeClaimed only

AnthropicIn code
CSSIn code
FastAPIIn code
HTMLIn code
JavaScriptIn code
PythonIn code
ReactIn code
RedisIn code
Tailwind CSSIn code
TypeScriptIn code
PyTorchClaimed

10 of 11 appear in the indexed code. 1 claimed on Devpost could not be matched to code, which may simply mean the tool leaves no trace in the repository.

AI coding agents

Claude CodeConfig · Commits

Detected from committed agent config files and commit authorship. Absence of a signal is not proof an agent was unused.

Codebase size

Source size

456 KB

Source files

Counts recognized source files only; vendored directories, binaries and lockfiles are excluded, so this is smaller than the repository on disk.

Feature verification

29 Verified3 Code-supported1 Claimed only

3D hologram-brain view (/graph) with firing memory visualizationVerified
A 3D hologram-brain view (/graph) where the retrieved memories fire the path that grounded each reply
Claimed on readmehigh confidence
- aac/frontend/src/components/HologramBrain.tsx:693 — applyHighlight lights subgraph/anchor/grounded nodes and animates a firing pulse along retrieved edges
- aac/frontend/src/views/GraphView.tsx:1 — GraphView hosts the hologram brain at the /graph route
Abstain / cold-start empty-graph handling with interview modeVerified
Solving the empty-graph cold-start, which led to the mode where the assistant interviews the user to build their brain
Claimed on Devposthigh confidence
- aac/backend/app/services/retrieval.py:570 — confidence gate triggers abstain when below threshold, asking for one more word
- aac/backend/app/services/learning.py:437 — interview_question drives the graph-aware Build-Your-Brain interviewer
- aac/frontend/src/components/BuildBrainPanel.tsx:1 — frontend panel drives the interview UI via /assistant_turn
Abstain when confidence is too low, asking for one more wordVerified
If confidence is too low it abstains ('add one more word') rather than guessing
Claimed on readmehigh confidence
- aac/backend/app/services/retrieval.py:574 — abstain = confidence < settings.confidence_threshold, with abstain_reason 'add one more word'
API surface: /health /generate /speak /confirm /assistant_turn /consolidate /style /stt /enroll /graph /trace/latestVerified
API endpoints listed in README
Claimed on readmehigh confidence
- aac/backend/app/main.py:218 — all listed endpoints are defined: /health, /generate, /speak, /confirm, /assistant_turn, /consolidate, /style/{id}, /stt, /enroll, /graph/{id}, /trace/latest
Arize Phoenix LLM tracing/evaluationVerified
Evaluation: Arize Phoenix
Claimed on Devposthigh confidence
- aac/backend/app/tracing.py:26 — init_tracing registers a local Phoenix/OpenInference OTel tracer; llm_span wraps LLM calls with OpenInference span attributes
- aac/backend/scripts/phoenix_grounding_proof.py:1 — supporting script for Phoenix grounding evaluation
Browser system-voice fallback when no voice enrolledVerified
Until a voice is enrolled it gracefully uses the best on-device system voice
Claimed on readmehigh confidence
- aac/frontend/src/hooks/useSpeak.ts:100 — playBrowserTTS uses window.speechSynthesis with a scored best-voice picker as fallback when audio_base64 is empty
Build your brain interview mode blooms new memories liveVerified
'Build your brain,' where a warm AI interviews you and each answer blooms a new memory onto the graph, live
Claimed on readmehigh confidence
- aac/backend/app/services/learning.py:157 — on_confirm creates/reinforces graph nodes+edges and returns new_nodes/new_edges for the frontend to bloom
- aac/frontend/src/components/BuildBrainPanel.tsx:187 — select() calls /confirm and passes result to onConfirmed for the graph view to bloom
Deepgram cloud STT integrationVerified
Voice (API): Deepgram
Claimed on Devposthigh confidence
- aac/backend/app/providers/stt.py:133 — DeepgramProvider implements the cloud STT path via Deepgram's /v1/listen endpoint
Degrades gracefully with lazy service construction (demo-safe boot)Verified
Every backend service is built lazily and degrades gracefully; the app boots and serves end-to-end even with no LLM/graph/TTS installed
Claimed on readmehigh confidence
- aac/backend/app/main.py:106 — _get() lazily constructs each provider/service, catching exceptions and caching None so endpoints degrade to shaped placeholders
Fully on-device / offline, private, nothing on core path touches the internetVerified
The whole thing runs on-device and offline so their private words never leave their hands
Claimed on Devpostmedium confidence
- aac/backend/app/providers/llm.py:41 — LMStudioProvider (local) is the default LLM; ClaudeProvider is explicitly opt-in/cloud
- aac/backend/app/providers/tts.py:78 — XTTSProvider is local/default; ElevenLabsProvider is opt-in cloud
- aac/backend/app/providers/stt.py:79 — WhisperLocalProvider is default; DeepgramProvider only used when an API key is configured
Hybrid GraphRAG retrieval with submodular optimization for fact selectionVerified
A hybrid retrieval pipeline traverses that graph and uses a submodular optimization to pick the most relevant facts
Claimed on Devposthigh confidence
- aac/backend/app/services/retrieval.py:106 — greedy_submodular implements Lin-Bilmes facility-location greedy maximization for fact selection
- aac/backend/app/services/retrieval.py:410 — retrieve() orchestrates anchor extraction, graph expansion, vector retrieval, re-rank, then submodular selection
Learned personal style model re-ranks candidates server-sideVerified
A learned personal style model re-ranks them (server-side) to sound like you
Claimed on readmehigh confidence
- aac/backend/app/services/style.py:288 — rank_candidates reorders candidates by style-fit against the learned profile
- aac/backend/app/main.py:306 — /generate calls style_svc.rank_candidates after generation
Learns the user's style over timeVerified
It learns their style the more they use it
Claimed on Devposthigh confidence
- aac/backend/app/services/style.py:159 — observe_confirm nudges a persisted per-person style profile toward chosen candidates vs rejected ones on each /confirm
- aac/backend/app/main.py:423 — /confirm calls style_svc.observe_confirm using the last generate's candidates as contrast set
On-device & airplane-mode capable with strictly opt-in cloud providersVerified
Local LLM, STT, TTS, embeddings and graph. Cloud providers are strictly opt-in
Claimed on readmehigh confidence
- aac/backend/app/config.py:17 — provider selection defaults are all local (lmstudio/local/whisper/xtts); cloud keys default empty
Online learning loop: reinforcement, consolidation, decayVerified
Every confirmation reinforces the graph; a consolidation pass promotes recurring patterns into durable preferences; and a scheduled decay pass (run_decay) fades what goes unused
Claimed on readmehigh confidence
- aac/backend/app/services/learning.py:519 — consolidate() infers Preference nodes from recent events via LLM
- aac/backend/app/services/learning.py:555 — run_decay delegates to GraphService.decay
- aac/backend/data/run_decay.py:1 — standalone script to run the decay pass
Personal 'brain' / living knowledge graph you can watch think, learn, and growVerified
A personal 'brain,' a living model of their world that you can watch think, learn, and grow
Claimed on Devposthigh confidence
- aac/backend/app/services/graph.py:79 — GraphService implements the Kuzu-backed personal knowledge graph with nodes/edges, salience, decay
- aac/frontend/src/components/HologramBrain.tsx:1 — 3D WebGL brain visualization that fires/highlights the retrieved subgraph for a generate call
Personal Knowledge Graph (Kuzu) of people, places, routines, preferences, phrasesVerified
An embedded Kuzu graph of the people, places, routines, preferences and phrases that make replies sound like you
Claimed on readmehigh confidence
- aac/backend/app/services/graph.py:22 — kind enum includes contact/place/topic/routine/preference/need/phrase, backed by Kuzu DDL
Redis local vector search (RediSearch) for node embeddingsVerified
Redis for local vector search
Claimed on Devposthigh confidence
- aac/backend/app/services/redis_store.py:48 — RedisStore implements a FLAT/COSINE RediSearch vector index with sync_person/knn methods used by retrieval as an optional backend
Register that fits the listener (partner detection drives term of address/tone)Verified
Partner detection drives the term of address ('sweetie'/'mijo'/'mi amor') and tone
Claimed on readmehigh confidence
- aac/backend/app/services/retrieval.py:283 — _detect_partner + addr_term mapping implement listener-aware term-of-address selection
Register/relationship-aware phrasing (e.g. sweetie vs mijo)Verified
The same words become 'sweetie' for a daughter and 'mijo' for a grandson depending on who they're talking to
Claimed on Devposthigh confidence
- aac/backend/app/services/retrieval.py:283 — _detect_partner identifies conversation partner; addr_term maps contact -> term of address, surfaced in facts block
- aac/backend/app/services/generation.py:32 — System prompt instructs the model to use the exact term of address shown in RETRIEVED FACTS
Sentence-transformers (bge-small) embeddingsVerified
Retrieval and embeddings: sentence-transformers, bge-embeddings
Claimed on Devposthigh confidence
- aac/backend/app/providers/embedding.py:59 — LocalEmbeddingProvider defaults to BAAI/bge-small-en-v1.5 via sentence-transformers
Sentry error monitoring integrationVerified
Observability: Sentry
Claimed on Devposthigh confidence
- aac/backend/app/observability.py:26 — init_sentry wires the FastAPI/Starlette Sentry integrations, offline-safe no-op without a DSN
- aac/backend/app/main.py:549 — /debug/sentry-error endpoint deliberately raises to demonstrate Sentry capture
Speech-to-text for capturing the partner's line via micVerified
Capture what the partner said with the mic (speech-to-text)
Claimed on readmehigh confidence
- aac/backend/app/providers/stt.py:79 — WhisperLocalProvider.transcribe decodes and transcribes audio
- aac/backend/app/main.py:502 — /stt endpoint exposes transcription to the frontend
Sponsor fit: ElevenLabs, Deepgram, ClaudeVerified
Sponsor fit - ElevenLabs (voice), Deepgram (STT), Claude (reasoning)
Claimed on readmehigh confidence
- aac/backend/app/providers/tts.py:138 — ElevenLabsProvider implements the cloud TTS fallback
- aac/backend/app/providers/stt.py:133 — DeepgramProvider implements cloud STT
- aac/backend/app/providers/llm.py:104 — ClaudeProvider implements cloud reasoning, used in consolidation
Tiles-first composition with optional type-to-add fieldVerified
Composition is tiles-first, the assisted user never has to type (an optional type-to-add field is there if they want it)
Claimed on readmemedium confidence
- aac/frontend/src/components/ConstructionStrip.tsx:1 — file matches for 'typed' input handling alongside tile-tap composition (onAddWord prop seen wired in BuildBrainPanel)
Tone dial nudges which register floats to the topVerified
A tone dial (warm / even / direct / playful) lets you nudge which register floats to the top
Claimed on readmehigh confidence
- aac/frontend/src/components/ToneDial.tsx:12 — ToneDial component with warm/even/direct/playful options
- aac/frontend/src/views/ConversationView.tsx:127 — orderByTone reorders generated candidates client-side by the selected tone's register priority
Two/three-word tap-to-sentence reconstructionVerified
Turns 2-3 tapped words into a full, natural sentence
Claimed on Devposthigh confidence
- aac/backend/app/services/generation.py:127 — generate_candidates builds a prompt from fragments + retrieved facts and asks the LLM for 3 full-sentence candidates
- aac/backend/app/main.py:228 — /generate endpoint wires retrieval -> generation into the full pipeline
Voice cloning in the user's own voiceVerified
Spoken in a clone of the person's own voice
Claimed on Devposthigh confidence
- aac/backend/app/providers/tts.py:78 — XTTSProvider.synthesize clones from a reference wav via Coqui XTTS-v2
- aac/backend/data/enroll_voice.py:1 — CLI script to enroll a person's reference voice sample
Zero-shot voice cloning (XTTS-v2), cache-first, offline replayVerified
Zero-shot voice cloning (Coqui XTTS-v2), cache-first so confirmed lines replay instantly and offline
Claimed on readmehigh confidence
- aac/backend/app/providers/tts.py:78 — XTTSProvider implements zero-shot cloning from a reference wav
- aac/backend/app/services/cache.py:29 — CacheService caches synthesized audio on-disk (offline-durable) plus Redis mirror
Frozen local model (Gemma via MLX on Apple Silicon) writes candidatesCode-supported
Steer a frozen local model (Gemma via MLX on Apple Silicon) to write the candidates
Claimed on Devpostmedium confidence
- aac/backend/app/providers/llm.py:41 — LMStudioProvider talks to a local OpenAI-compatible server (LM Studio), consistent with running Gemma via MLX, but the code itself doesn't reference MLX or pin Gemma; the model is whatever LM Studio is configured with
Sixty-second latency bug fixed by disabling wasted reasoning tokensCode-supported
Responses took sixty seconds until we found the model was burning thousands of reasoning tokens we then discarded, and turning that off made it near-instant
Claimed on Devpostmedium confidence
- aac/backend/app/config.py:30 — lm_studio_reasoning_effort defaults to 'none' with a comment describing disabling Gemma-4's chain-of-thought for large latency win, consistent with the claim, though the specific 60s->instant figure is not independently verifiable from code
Style/preference learning uses an RLHF-like preference formulationCode-supported
A style model learns the user's phrasing from which suggestions they pick, using the same preference formulation behind RLHF
Claimed on Devpostmedium confidence
- aac/backend/app/services/style.py:159 — observe_confirm implements a contrastive (chosen vs rejected) online weight update, a lightweight logistic-style nudge; plausible but not literally an RLHF/DPO implementation
Race condition fix for stale suggestionsClaimed only
We also fixed a race that resurrected stale suggestions against the wrong line of conversation
Claimed on Devpostlow confidence

An AI agent derived these features from the project’s Devpost page and readme, then searched the code for each one. Verified features are backed by cited code; claimed-only features had no supporting code, which is not by itself proof a feature is missing.