Monday

Monday AI-powered assistive grasping glove that sees, thinks, and moves your fingers for you.

Inspiration Over 80 million people worldwide live with upper motor neuron injuries — conditions like stroke, spinal cord injury, and cerebral palsy that leave the brain's "reach" signal intact but sever the pathway to close the hand. A stroke survivor can extend their arm toward a coffee mug but cannot complete the grip. Existing solutions are either prohibitively expensive robotic exoskeletons or require months of manual physical therapy before any functional recovery. We asked: what if you could skip the exoskeleton entirely and use the patient's own muscles? What if an AI agent could see what you're reaching for, decide how to grip it, and electrically stimulate your fingers to close — all in under two seconds? That's Monday. Named after the assistant who handles everything so you don't have to.

What it does Monday is a wearable AI assistant that restores grasping ability using electrical muscle stimulation (EMS). The user wears a lightweight forearm gauntlet with three TENS electrode channels (index, middle, and pinky fingers) and a head-mounted webcam with a built-in microphone. Here's the flow: Wake. The user says "hey monday" to activate the system. faster-whisper runs locally on the Raspberry Pi for fast wake-phrase detection. Listen. The user speaks a natural language command: "grab the cup," "pick up the pen," "get the key." See. A Logitech webcam captures the scene in front of the user. OpenCV grabs the frame and encodes it. Think. The frame and transcript are sent to Claude's vision API. Claude classifies the object, evaluates safety (refusing sharp or hot objects), selects one of three grip types (cylindrical, pinch, or lateral), and returns a structured JSON command sequence with a confidence score. Speak. Monday acknowledges the plan via text-to-speech: "Grabbing the cup with a cylindrical grip." On lower confidence, it adds "say stop if wrong," giving the user an abort window. Act. The Arduino Micro fires three relays that gate a Belifu TENS unit's output into the dorsal-hand electrodes. The user's own finger flexors contract and close around the object. The entire pipeline — from voice command to muscle contraction — runs in under 2 seconds.

How we built it Hardware Stack Raspberry Pi 5 — The wearable brain. Runs three Flask microservices: camera capture (port 5002), audio streaming (port 5003), and the Arduino serial bridge (port 5001). All communication happens over a phone hotspot network. Arduino Micro — Drives three active-HIGH relay modules via direct PORTD register manipulation for sub-microsecond switching. Enforces a 5-second max-on safety cap and boot-OFF guarantee. 3-Channel Relay Board — Gates the positive output of the Belifu EMS unit into three separate electrode pairs on the dorsal hand (index, middle, pinky metacarpals). Shared ground electrode on the wrist. Belifu TENS/EMS Unit — Medical-grade muscle stimulator providing the actual electrical impulse. Intensity is set manually on the physical dial during calibration. Logitech Webcam — Serves as both the camera (1280×720 JPEG capture) and the microphone input, mounted on the user's head for a first-person view of the workspace. Software Stack Python 3.11 — Core application language across both Pi and laptop Anthropic Claude API— Vision + language model that serves as the "brain." Receives a base64 JPEG frame and voice transcript, returns a validated JSON grip plan with confidence scoring and safety refusals faster-whisper — Local speech-to-text for wake-phrase detection and intent capture. Runs the base model on CPU with beam_size=1 for low-latency transcription of rolling 3-second audio windows OpenCV — Frame capture, encoding, and real-time overlay display showing system state, transcripts, confidence indicators, and refusal alerts Flask — Three lightweight HTTP microservices on the Pi (camera, audio, hardware bridge) enabling clean separation between the wearable hardware and the application logic PySerial — USB serial communication between the Pi and Arduino at 115200 baud pyttsx3 — Text-to-speech for spoken acknowledgements ("grabbing the cup with a cylindrical grip") PyQt5 — Calibration GUI for electrode placement and intensity tuning, with a built-in safety verification suite sounddevice + PortAudio — Real-time audio capture and streaming from the webcam microphone pytest — Full test suite covering brain validation, orchestrator state machine, voice processing, and priority-stop latency Architecture The system is split across two machines connected over a phone hotspot: ┌─────────────────────────────────┐ ┌──────────────────────────────────┐ │ WEARABLE (Pi 5) │ │ LAPTOP (Bench) │ │ │ │ │ │ webcam ──► camera_service:5002 │────►│ vision.py (HTTP client) │ │ mic ──► audio_service:5003 │────►│ voice.py (Whisper + VAD) │ │ Arduino ◄── receiver.py:5001 │◄────│ orchestrator.py (state machine) │ │ │ │ │ brain.py (Claude API) │ │ ▼ │ │ main.py (overlay + hotkeys) │ │ 3 relays ──► EMS electrodes │ │ │ └─────────────────────────────────┘ └──────────────────────────────────┘

Every layer assumes the layers above and below may fail. Safety is enforced at five independent levels: physical kill switch → firmware watchdog and max-on cap → HTTP bridge validation → orchestrator abort window → Claude's refusal logic.

Claude selects the grip type based on visual classification of the object shape. When ambiguous, it defaults to the grip less likely to cause injury if fired incorrectly.

Safety Architecture Working with electrical muscle stimulation on human skin during a hackathon demanded an obsessive approach to safety. Physical kill switch — An SPST switch inline with the EMS positive lead. Hardware-level, operator-independent, bypasses all software. This is the primary safety mechanism. Firmware (Arduino) — Enforces a 5-second max-on cap per activation. Any relay energized longer than 5 seconds is force-killed with an AUTO-OFF signal. Boots with all relays OFF. HTTP Bridge — Caps duration_ms at 1000ms per command. Validates all enum values. Serializes writes so commands cannot interleave. Priority /stop endpoint bypasses the command lock (benchmarked at 2.7ms on localhost). Orchestrator — Adds a 500ms abort window after every TTS acknowledgement. User can say "stop" or press the kill key during this window. Scales pulse durations down by confidence (LOW = 50% duration). Claude Brain — Refuses to fire for sharp objects, hot objects, empty scenes, non-grasp intents, and motions the system cannot produce. When uncertain, outputs LOW confidence to trigger the extended abort window. A dedicated calibration GUI (stimGUI.py) with a Verify Safety button runs a four-step end-to-end check before every session: fire a test pulse, send a priority stop after 200ms, verify stop latency is under 100ms, and confirm no pulse is still in flight.

Challenges we faced Electrode crosstalk. The three finger channels are only centimeters apart on the dorsal hand. At higher intensities, stimulating the index channel would cause visible twitching in the middle finger. We spent hours on calibration — adjusting electrode placement millimeter by millimeter, tuning intensity one dial click at a time, and documenting every configuration in our calibration log. Network latency over phone hotspot. The Pi and laptop communicate over a phone hotspot, and DHCP reassignment meant the Pi's IP would change between sessions. mDNS (.local hostnames) failed on most phone hotspots. We ended up SSHing into the Pi and running hostname -I before every demo session. Claude response latency. The initial implementation used claude-sonnet-4-5 which added 1-3 seconds to the pipeline. We switched to claude-haiku-4-5 and tuned the JPEG upload quality, cutting API latency by roughly 2-5x without any loss in grip classification accuracy. Wake phrase detection in a noisy hackathon. 500+ students in the Purdue Armory created a brutal acoustic environment. We tuned the VAD threshold, experimented with different Whisper model sizes, and eventually added a manual keyboard trigger as a fallback (ManualTrigger fires on SPACE + typed intent).

Accomplishments that we're proud of It actually works on a real person. We went from zero hardware to a working EMS glove that grips real objects — a water bottle, a pen, a key — in 36 hours. We even played a piano with it. Five-layer safety architecture. We built a system that puts electrical current through human skin at a hackathon and did it safely enough to demo repeatedly without a single unintended stimulation. Sub-2-second pipeline. Voice command to muscle contraction in under 2 seconds. Fast enough to feel responsive, not robotic. A real test suite during a hackathon. Brain validation, orchestrator state machine, voice processing, priority-stop latency — all covered under pytest. Claude as a grip planner. Using a vision-language model as the decision engine for a physical system is an unconventional architecture choice. Claude's ability to reason about object safety (refusing knives, hot objects) and grip ambiguity (thick marker: pinch or cylindrical?) made it a surprisingly good fit.

What we learned EMS electrode placement is as much art as science. The same electrode position that gives a clean index twitch on one person produces nothing on another. Calibration is everything. Splitting the system across two machines (Pi wearable + laptop bench) over a phone hotspot was the right architectural call — it kept the wearable lightweight — but networking edge cases consumed more time than expected. Claude's structured JSON output mode is remarkably reliable for safety-critical applications. In our 8-case test suite, it produced valid, correctly-formatted responses 100% of the time with the retry logic. Physical kill switches are non-negotiable for any EMS project. Software can fail. A switch on a wire cannot.

What's next for Monday Thumb actuation. The current three-finger topology is a fixed hardware constraint. Adding a fourth channel for thumb opposition would unlock precision grips and expand the usable object set dramatically. Closed-loop feedback. Currently Monday fires and hopes. Adding force-sensing resistors to the fingertips would let the system detect successful grip and automatically adjust duration and intensity. On-device inference. Moving from cloud-based Claude API calls to an on-device vision model would eliminate network dependency and cut latency to sub-500ms. Clinical validation. Partnering with Purdue's School of Health Sciences to test Monday with actual upper motor neuron injury patients in a controlled rehabilitation setting. EMG integration. Adding electromyography sensors to detect residual voluntary muscle signals. The system could learn to amplify the patient's intent rather than replacing it entirely.

Built in 36 hours at StarkHacks 2026 — the World's Largest Hardware Hackathon at Purdue University.