Project Info
Technical Overview https://www.loom.com/share/5348b74c2fd14f47992c22fadabc2f57
Inspiration
Imagine having a perfectly clear mind but being unable to communicate it to the world. For millions of people living with ALS, recovering from a stroke, or dealing with severe paralysis, the standard ways we interact with technology like typing on a keyboard or speaking to a voice assistant are often impossible. We realized that current tools fail exactly where they are needed most and for users who physically cannot use their hands or produce clear speech. This gap in assistive technology is what drove us to build MindOS. We wanted to create a solution that works even when a user is silent to provide a lifeline for communication and control without requiring direct brain implants or invasive procedures.
What it does
MindOS is a silent speech AI agent for your computer powered by micro muscle signals. With sensors placed along the jaw and throat region, a user can silently think about certain actions without making a sound. The system decodes that intent to control a computer. It allows for reliable actions like silent web browsing where a user can scroll, go back, or search. Unlike standard voice control, MindOS works when speech is difficult or impossible and supports hands-free usage. It also incorporates a frontend with inference that enables users to append new training data. This means the software learns based on any new user rather than just guessing.
How we built it
We built MindOS as a modular pipeline that connects signals to digital actions. Hardware & Signal Ingestion: On the hardware side, we used two Myoware muscle sensors attached to the jaw via electrodes. These sensors capture raw EMG data, which is passed to an Arduino Uno. We utilized PySerial to ingest this serial port data into our laptop for real-time processing. Signal Processing: We treated the muscle signals as time-series data, applying noise handling to filter out motion artifacts. We then processed the data with a classification-based Random Forest model to categorize English phonemes into four distinct biometric signatures based on EMG muscle activation. AI Agents: Since raw signals are ambiguous, we implemented a multi-agent workflow to bridge the gap between signal and action: Context Agent: Because we were mapping limited signal categories to the complexity of human language, we built an intelligent agent to suggest the correct character or word based on context. Action Agent: Once the intent is understood, a second agent decides which specific browser action to take. Execution Agent: We used Playwright to drive the actual browser automation based on the Action Agent's decisions.
Challenges we ran into
Our biggest hurdle was the hardware limitation. We ideally wanted to build a 26-class classifier to map signals directly to the alphabet. However, since we were limited to two muscle sensors and fewer than 20 electropads, we couldn't capture enough distinct data points for that level of granularity. We were stuck with just 4 distinct signal categories trying to map to 26 letters. To bridge this gap, we first implemented an exhaustive-but-pruned greedy search that enumerates possible letter sequences from the low-entropy signal stream and filters them using an English lexicon and frequency priors, dramatically shrinking the candidate space to linguistically plausible outputs. On top of that, we deployed a lightweight GPT-mini context agent that evaluates the remaining candidates against preceding text, grammar, and semantic coherence to select the most likely intended sequence in real time. This allows the system to ignore invalid combinations and lock onto the correct word based on probability and context. Finally, ensuring the agent didn't hallucinate actions was difficult. We solved this by leveraging conservative AI prompts rather than giving it total freedom. This balance between speed and reliability was tough to find, but limiting the command set ensured our demos were high-confidence rather than chaotic.
Accomplishments we're proud of
We shipped an end-to-end assistive interface that connects biological sensors to real computer actions within a hackathon timeframe. We are particularly proud of our real-time EMG decoding pipeline and the robust API boundary we built for fast iteration. We achieved 96% accuracy on our model using a dataset of six hours of raw sub-vocal recordings, which we augmented to simulate variance and noise. Additionally, we successfully integrated multi-layer LLMs (using GPT-4o) to drive the decision-making process, proving that we could control a browser with nothing but silent intent.
What we learned
We learned that the hardest part isn't just modeling. It is making the experience reliable when dealing with the messiness of real-world sensors. Electrode placement, skin contact, and small movements can shift signals significantly. We also discovered that constraining the interaction space dramatically improves trust; tool-based execution is essential for predictable agents. On a personal level, we learned the value of perseverance. Even when the hardware signals were noisy or the model failed to generalize, we pushed through to refine our pipeline until it worked.
What's next
Next, we want to improve the calibration features so the system adapts quickly to new users. We plan to expand the vocabulary of commands while keeping reliability high, using our feedback logs to continually improve decoding accuracy. For the future, we hope to implement multi-sensor fusion across the face to capture accurate and faster data. We also aim to move to on-device processing. By moving to an on-edge device, we can reduce latency and ensure that MindOS becomes a private, secure, and viable daily-use product for many people in need.
MindOS — TreeHacks 2026
MindOS is a non-invasive silent speech interface that converts micro muscle signals (EMG) from the jaw and throat into real computer actions.
It enables users to communicate and control software without speaking or using their hands.
🎥 Demo
💡 Inspiration
Imagine having a perfectly clear mind but being unable to communicate it to the world. Millions of people living with ALS, recovering from stroke, or experiencing severe paralysis cannot rely on keyboards or speech interfaces. Existing tools fail exactly where assistive technology matters most.
We built MindOS to create a non-invasive interface that translates silent intent into digital action — providing a pathway for communication and control without implants, speech, or physical movement.
What it Does
-
Silent intent → action
Users silently mouth commands detected through EMG signals -
Hands-free computer control
Browse, search, scroll, and navigate without a keyboard or voice -
Adaptive learning loop
Users can append new training data to personalize decoding -
Assistive-first design
Built for people who cannot rely on speech or motor input
How It Works
MindOS is a modular pipeline that connects biological signals to digital actions.
1. Hardware & Signal Ingestion
- Two MyoWare EMG muscle sensors placed along the jaw
- Signals routed through an Arduino Uno
- Real-time streaming via PySerial into the processing pipeline
2. Signal Processing
- Treated EMG as time-series data
- Applied noise filtering to remove motion artifacts
- Random Forest classifier maps signals to four biometric phoneme classes
3. Multi-Agent Decision Layer
Because EMG signals are low-entropy, we designed a structured agent workflow:
-
Context Agent
Infers likely characters/words using linguistic priors -
Action Agent
Determines which computer command the user intends -
Execution Agent
Uses Playwright to perform browser automation safely
Reliability Layer
A plug-and-play signal interface allows switching between:
- Live sensor input
- Mock signals for deterministic demos
Key Components
- EMG signal ingestion via PySerial
- Random Forest classification
- Lexicon-filtered candidate generation
- LLM-based contextual disambiguation
- Tool-constrained agent execution
- Browser automation with Playwright
Tech Stack
Hardware
- MyoWare EMG sensors
- Arduino Uno
ML / Signal Processing
- Python
- Scikit-learn (Random Forest)
- Time-series preprocessing
AI & Agents
- GPT-4o (decision layer)
- Custom context + action agents
Automation
- Playwright
Frontend / Interface
- Web UI for calibration + data collection
Challenges
Limited Signal Resolution
With only two sensors, we could not build a full 26-class alphabet classifier.
We were constrained to four signal categories.
Accomplishments
- Built a full end-to-end assistive interface in a hackathon timeframe
- Achieved 96% classification accuracy on six hours of EMG data
- Successfully controlled a live browser using silent intent
- Designed a robust modular API for rapid iteration
What We Learned
- Real-world biosignals are noisy and highly user-dependent
- Calibration and UX matter as much as model accuracy
- Constrained agent design dramatically improves trust
- Hardware-software co-design is essential for assistive tech
What’s Next
- Faster calibration for new users
- Expanded command vocabulary
- Multi-sensor fusion across facial muscle groups
- On-device inference for lower latency and better privacy
- Continuous learning from feedback logs
Why It Matters - Impact
We started this project because we know people personally that would want to work or even just be on their computer, but cannot. MindOS demonstrates that assistive computing doesn’t require invasive brain implants. By decoding neuromuscular signals already present during silent speech, we can create interfaces that restore autonomy and communication for millions of people.
Acknowledgements
Thanks to the mentors, organizers, sponsors, and everyone else for their support at TreeHacks 2026.
Analysis
View
Metric
- 7
- 3
- 2
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
- CSSIn code
- ExpressIn code
- FastAPIIn code
- JavaScriptIn code
- Next.jsIn code
- OpenAIIn code
- PythonIn code
- ReactIn code
- Tailwind CSSIn code
- TypeScriptIn code
- C++Claimed
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
No AI coding agent signals were found in this repository.
Detected from committed agent config files and commit authorship. Absence of a signal is not proof an agent was unused.
Codebase size
Source size
534 KB
Source files
74
Counts recognized source files only; vendored directories, binaries and lockfiles are excluded, so this is smaller than the repository on disk.
Repository
shawncshen/treehacks-2026
90 files · 890 KB · @ 3cda19f
Structure
Interface
10 files · 11%Screens, components and styles rendered to the user.
API & routing
3 files · 3%Request entry points: routes, handlers and controllers.
Application logic
40 files · 44%Domain rules, services and shared utilities.
Supporting
Layers are inferred from where files sit in the tree, not from reading the code. A project that names its directories unconventionally will read oddly here — open the file browser to check anything the diagram implies.
Languages
- Python63%
- Markdown26%
- TypeScript10%
- YAML0%
- JavaScript0%
- CSS0%
Share of indexed source by file size. Binary and vendored files are excluded.
Dependencies
silentpilot/pyproject.toml
pypi · 13- fastapi
- joblib
- numpy
- pydantic
- pyserial
- python-dotenv
- scikit-learn
- scipy
- uvicorn[standard]
- websockets
- +3 more
silentpilot/app_ui/package.json
npm · 11- next
- react
- react-dom
- recharts
- +7 more
silentpilot/agent/package.json
npm · 9- dotenv
- express
- openai
- ws
- +5 more
silentpilot/mcp_server/package.json
npm · 8- @modelcontextprotocol/sdk
- express
- playwright
- zod
- +4 more
Declared in the repository’s manifests at the indexed commit. A declared package is not proof it is used, and runtime dependencies are listed first.
This project’s features have not been analysed yet.
Export this project's context (description, README, evidence, key source files) to chat with an AI agent elsewhere.
