Project Info

Winner

Snap: Dream it. Build it.; Fetch.ai: Agentic Track Prize

RecovARy

This project did not submit a demo video on Devpost.

Inspiration

We were inspired to build RecovARy after attending Physical Therapy for the last few weeks. One of us was diagnosed with muscle spasms in their neck. After being diagnosed with muscle knots by experienced doctors, they were told the only way to fix this challenging and painful obstacle was to increase mobility in their body. Although their story involved muscle spasms, I designed this app to take it a step further, for patients who require mobility after having a stroke. A stroke, if you aren't aware, damages brain cells due to a reduced blood flow to the brain, and thus, one of many things in the body that are affected are regular movement and mobility. Therefore, we created this app with two distinct AR games, allowing a patient to choose from either Wall Tennis or 3D Fruit Ninja.

What it does

Our app essentially contains two video games: Wall Tennis focuses on restoring a patient's arm power, including movement in the arms, shoulders, and wrists, and we calculate a patient's hitting speed to see how much mobility they are gaining in their arms; Fruit Ninja focuses on hand-eye coordination and calculates a patient's reaction time.

How we built it

We built this app using the following technologies: Snap Inc. Spectacles, Lens Studio, Fetch.ai, Groq, Xano, and React JS

Challenges we ran into

A couple of challenges that I ran into was trying to change the entire concept of Wall Tennis into Squash. However, I noticed that the game was turning more into Virtual Reality, meaning I couldn't see the real world around me anymore and rather was completely immersed in the lens' objects instead of partially. Therefore, I changed the game back to Wall Tennis.

Accomplishments we're proud of

We were proud of not only being able to develop these two video games but also being able to fetch two data values from Lens Studio (hitting speed from Wall Tennis and reaction time from Fruit Ninja) to calculate and analyze a patient's data to create an accurate and effective report for doctors/physical therapists to see how much mobility their patient is gaining.

What we learned

We learned how to work together fight through obstacles, and even create a fully fleshed-out product given our limited time frame.

What's next

We would love to create a wider variety of games for patients to choose from, perhaps focusing on other parts of mobility than just hitting speed from the arm, and reaction time calculating a patient's reaction time. Another game we had in mind was inspired by Valorant's shooting range, where several objects would spawn in random locations and the patient would get a limited time (a split second) to hit the object before it disappeared.

Analysis

Compare with all teams

View

Metric

No commits on this project resolved to a GitHub account.

Technology

Found in codeClaimed only

CSSIn code
HTMLIn code
JavaScriptIn code
PythonIn code
ReactIn code

5 of 5 appear in the indexed code.

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

31 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

3 Verified4 Code-supported2 Claimed only1 Blocked

Fetch.ai uAgents multi-agent architectureVerified
Built with Fetch.ai for agent-based data processing
Claimed on Devposthigh confidence
- wrapper_agent.py:26 — Defines a wrapper_agent using uagents.Agent that dispatches requests to sub-agents (age/gender, body parts, stroke cause, game data) and aggregates responses
- age_and_gender_agent.py:9 — Separate uagents.Agent instance handling age/gender-specific recovery plan generation
- body_parts_impacted_agent.py:17 — Separate uagents.Agent instance for body-parts recovery plan generation
- incident_type_agent.py:17 — Separate uagents.Agent instance for stroke-cause recovery plan generation, reading patient_data.json
Groq LLM-generated recovery planVerified
Built with Groq to generate personalized recovery plan/report for doctors/PTs
Claimed on Devposthigh confidence
- wrapper_agent.py:99 — Calls Groq chat.completions.create with combined prompt from all sub-agent data and writes result to personalized_weekly_plan.txt
- age_and_gender_agent.py:31 — Calls Groq API (llama3-8b-8192) to generate an age/gender-based plan
- snap_game_agent.py:72 — Calls Groq API (gemma-7b-it) to generate a plan from fetched game scores
React JS dashboard for patients/doctorsVerified
Built with React JS for the frontend/dashboard
Claimed on Devposthigh confidence
- recovery-dashboard/src/App.js:60 — React functional component rendering a typing-effect display of the recovery plan text
- recovery-dashboard/src/components/RecoveryPlan.js:5 — React component fetching and displaying combined recovery plan via axios
- recovery-dashboard/src/components/SnapGameData.js:6 — React component charting speed/reaction-time game data via recharts, fetched via axios
Backend API wiring dashboard to agent-generated planCode-supported
Implicit: the app serves the doctor/PT-facing report generated from game+patient data
Claimed on Devpostlow confidence
- server.py:12 — Flask /data POST route exists but calls wrapper_agent.generate_groq_combined_plan without awaiting/invoking it as a coroutine correctly (missing parentheses), and returns literal string 'LOL' — inconsistent with the '/api/patients/1/report/' and '/api/patients/1/game-data/' endpoints the React components actually call
- recovery-dashboard/src/components/RecoveryPlan.js:10 — Frontend expects a '/api/patients/1/report/' endpoint that does not exist in server.py
Hitting speed calculation from Wall TennisCode-supported
App calculates a patient's hitting speed to gauge arm mobility gains
Claimed on Devpostlow confidence
- speed_recovery_agent.py:4 — Defines a GameData model with speed_data list and an agent that logs/receives it, but data is only simulated by remote_agents_slaanesh.py-style random generators, not sourced from a real Lens Studio game
- remote_agents_sigmar.py — Simulated random speed sender agent generating fake speed values, not real game telemetry
Reaction time calculation from Fruit NinjaCode-supported
App calculates a patient's reaction time from the Fruit Ninja game
Claimed on Devpostlow confidence
- reaction_time_recovery_agent.py:4 — Defines ReactionTimeData model and an agent stub that logs reaction time data, but no real Lens Studio source feeding it is present in this repo
Xano backend integration for game scoresCode-supported
Built with Xano as a backend data store
Claimed on Devpostmedium confidence
- snap_game_agent.py:7 — Hardcodes a Xano API URL (x8ki-letl-twmt.n7.xano.io) and fetches patient game scores via POST requests, though fetch_scores is called with only one positional arg while defined with two (patient_scores_id, game_type), suggesting this code path is broken/untested
AR Fruit Ninja game (Snap Spectacles / Lens Studio)Claimed only
3D Fruit Ninja AR game for hand-eye coordination, calculating reaction time
Claimed on Devposthigh confidence
AR Wall Tennis game (Snap Spectacles / Lens Studio)Claimed only
AR game restoring arm power via Snap Spectacles/Lens Studio, calculating hitting speed
Claimed on Devposthigh confidence
Two distinct AR games selectable by patientBlocked
Patient chooses from either Wall Tennis or 3D Fruit Ninja
Claimed on readmehigh 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.