This is a submission for the *Hermes Agent Challenge*: Build With Hermes Agent
(had to edit as code block wasnt rendered properly)
What I Built
CareSync is a CLI-based caregiving assistant that helps me keep track of everything related to caring for my grandmother.
I'm Naomi, a 21-year-old engineering student. Between classes, assignments, and part-time work, I also help care for my grandma, Kamala. Over time, I realized that caregiving is surprisingly difficult to manage.
A symptom might be mentioned over breakfast. A medication change could happen after a doctor visit. A few weeks later, someone asks, "Has this happened before?" and suddenly I'm digging through WhatsApp messages, notes, and my memory trying to find the answer.
I built CareSync to solve that problem.
CareSync acts as a personal caregiving command center. It stores observations, symptoms, medications, reports, and important events in a local SQLite database, making them searchable and easy to organize.
For example, I can quickly log a symptom:
./caresync add "Kamala felt dizzy after breakfast"
Search past events:
./caresync search --person Kamala --query dizziness
Generate a doctor-ready summary:
./caresync brief --person Kamala --days 14
Or create handoff notes when another family member takes over care:
./caresync handoff --person Kamala --for-person Aunt
CareSync isn't just a record-keeping tool. It helps answer questions, identify recurring patterns, prepare for appointments, and keep family members aligned.
Key capabilities include:
- Quick logging of symptoms, meals, medications, vitals, and observations
- Searching historical events and recurring symptom patterns
- Medication tracking and report imports
- Appointment briefs and doctor question generation
- Caregiver handoff summaries
- Audit logs for transparency
- Natural-language workflows powered by Hermes Agent
- Local-first storage using SQLite
CareSync does not provide medical advice. Its goal is to help caregivers remember less, stay organized, and feel more prepared.
Demo
The demo follows a typical caregiving workflow using CareSync.
It starts with logging a new symptom after Grandma mentions feeling dizzy. From there, CareSync is used to search past observations, helping answer an important question before a doctor visit: "Has this happened before?"
Next, the demo shows how CareSync can generate suggested questions for the doctor and create a concise appointment summary based on recent observations.
The demo also highlights Hermes Agent's natural-language capabilities. Instead of manually searching records, I can ask questions like:
Has Grandma been dizzy before?
Hermes searches the caregiving history, identifies relevant events, and returns a summarized answer with supporting context.
Finally, the demo demonstrates transparency through the audit log, showing how actions performed by the agent can be reviewed and traced.
Example commands shown in the demo:
./caresync add "Kamala felt dizzy after breakfast"
./caresync search --person Kamala --query dizziness
./caresync timeline --person Kamala
./caresync questions --person Kamala
./caresync brief --person Kamala --days 14
./caresync handoff --person Kamala --for-person Aunt
./caresync chat "has grandma been dizzy before?"
./caresync audit
Code
Repository: https://github.com/Byte-Sized-Brain/caresync
Architecture
My Tech Stack
Core Technologies
- Hermes Agent – Natural-language orchestration and skill execution
- Python 3.12 – Core application and CLI implementation
- SQLite – Local-first storage for observations, medications, reports, and audit logs
- agentskills.io – Custom Hermes skill definitions and execution
- Terminal-based CLI – Primary interface for caregivers
- Nous Portal – Development, testing, and agent deployment
Hermes Skills
CareSync is powered by seven custom Hermes skills:
- log-health-event – Record symptoms, meals, vitals, medications, and observations
- symptom-search – Search historical records and identify recurring patterns
- medication-tracker – Manage medications, doses, and prescriptions
- import-report – Import reports and prescription information into memory
- appointment-brief – Generate summaries for upcoming doctor visits
- handoff-notes – Create caregiver transition summaries for family members
- doctor-questions – Suggest follow-up questions based on observations and reports
Storage Philosophy
CareSync is designed to be local-first. All caregiving information is stored in a local SQLite database rather than a cloud service, giving caregivers full ownership of their data while enabling long-term searchable memory.
How I Used Hermes Agent
CareSync started as a collection of CLI tools for managing caregiving information. While the commands are useful, caregiving often involves answering questions rather than running specific commands.
That's where Hermes Agent comes in.
Hermes acts as an orchestration layer on top of CareSync's tools and memory. Instead of remembering which command to run, I can describe what I need in natural language and Hermes determines the appropriate actions.
For example, I can ask:
Has Grandma been dizzy before?
Hermes searches historical observations, reviews matching events, identifies patterns, and returns a concise answer based on information stored in CareSync.
The biggest advantage came from multi-step workflows.
Consider the request:
Prepare me for tomorrow's doctor appointment.
Instead of manually reviewing notes and running several commands, Hermes can:
- Search recent symptoms and observations
- Review medication history
- Generate suggested doctor questions
- Create an appointment summary
All from a single request.
Hermes is also useful for family coordination. When another family member takes over caregiving responsibilities, the agent can gather recent observations, medication updates, and upcoming appointments to generate a clear handoff summary.
The terminal tool was particularly valuable because Hermes performs real actions against the CareSync CLI rather than generating responses from memory alone. Every action interacts with actual data stored in SQLite and is recorded in an audit log.
This makes CareSync feel less like a collection of commands and more like an assistant that understands caregiving workflows. Hermes handles the reasoning and orchestration, while CareSync provides the tools and long-term memory.
Why I Built This
I built CareSync because I experienced this problem myself.
As a student, I help care for my grandmother, Kamala. Important details like symptoms, medication changes, and doctor recommendations were often spread across messages, notes, and memory.
CareSync gives me one place to record, search, and organize that information, making it easier to prepare for appointments and keep family members informed.
Its goal is simple: reduce the mental load of caregiving and help families stay organized.
Top comments (7)
Can't wait to see a local LLM used for something like this. Keeping sensitive caregiving data fully on-device while still enabling natural-language search, appointment summaries, and pattern recognition feels like a perfect fit for local AI. The local-first approach already adds a lot of value, and an offline AI assistant could make it even more useful for caregivers and families.
Thanks! A local LLM is definitely something I'd love to explore. Since caregiving data is so personal, being able to keep everything on-device while still getting natural language search and summaries would be a huge win for privacy and usability.
great usecase fr!
thanks!!
Really cool project . Love how it tackles a real caregiving challenge with a local-first approach. Curious, how are you planning to handle deployment and syncing if multiple family members need access to the same records?
Great question! CareSync is currently local-first and focused on a single caregiver workflow. For now, coordination happens through the handoff notes feature, which lets caregivers share relevant context without syncing the entire database. In the future, I may explore encrypted sync or self-hosted sharing options while keeping privacy and data ownership at the core.
Love this idea. Turning caregiving history into searchable memory feels like a perfect use case for AI agents.