SlowSloth 🦥
Hacktoberfest Open-Source AI Challenge — Week 3: Slow and Steady
Less time organising work. More time doing it.
What if your task manager could do more than store your to-do list? What if you could describe everything on your mind, review an organised plan, and have a little sloth on your desk remind you when something important is approaching?
Meet SlowSloth 🦥 — a personal AI task-management assistant I’m developing for the Arduino UNO Q, with Gemma 3 1B selected for local AI inference and the board’s built-in LED matrix providing a physical reminder experience.
The idea is simple: reduce the effort of managing commitments so there is more time and mental energy for the work that matters.
GitHub: github.com/nimalan-parameswaran/SlowSloth
The problem: Managing work has become work of its own
I’m a student, and my life rarely revolves around just one thing.
There are hackathons to participate in, research to complete, courses and workshops to attend, competitive exams to prepare for, social volunteering to contribute to, and family and friends to make time for.
I genuinely enjoy being involved in these activities. Each one gives me an opportunity to learn, contribute, or work on something I care about.
But there is a side of a busy life that people don’t always talk about.
Managing everything can become exhausting before the actual work even begins.
A research idea comes to mind while I’m attending a workshop. An exam deadline approaches while I’m working on a hackathon. A volunteering commitment needs attention just when I’ve planned to finish a project.
Every commitment creates its own administrative work:
- Write it down.
- Remember the deadline.
- Decide how important it is.
- Find time to do it.
- Keep track of what remains.
- Remember to come back to it.
Sometimes, I would postpone recording an idea because I didn’t want to interrupt what I was doing to create another task manually. Later, I would have to reconstruct the idea, decide what mattered most, and figure out when I could actually work on it.
Eventually, I started asking myself:
What if managing my tasks didn’t require so much effort from me?
I didn’t want another productivity application that gave me a bigger to-do list to maintain. I wanted an assistant that could help with the repetitive administrative work behind getting things done.
That idea became SlowSloth.
The name reflects a simple thought: being slow doesn’t necessarily mean being lazy. Sometimes, the smartest thing you can do is stop wasting energy on repetitive work.
From a messy thought to an organised plan
Imagine I’m working on my battery research when three other things suddenly come to mind:
“I need to finish my hackathon README, review the battery model results, and prepare for my exam. The research results are probably the most urgent.”
With a conventional task manager, I would need to create three entries, assign priorities, enter deadlines, and work out how to fit them into my schedule.
SlowSloth is designed to make that process more natural.
Instead of manually organising every thought, I want to describe what needs to happen and let the assistant help identify individual actions, extract relevant details, suggest priorities, and propose a schedule.
The intended workflow is:
Capture → Understand → Prioritise → Propose → Confirm → Schedule → Remind → Track
- Capture: Start with a natural-language description.
- Understand: Identify potential tasks and relevant details.
- Prioritise: Suggest which tasks deserve attention first.
- Propose: Find suitable scheduling options based on deadlines and availability.
- Confirm: Let the user review important decisions.
- Schedule: Connect approved scheduling actions to Google Calendar when configured.
- Remind: Provide a physical cue as a task or event approaches.
- Track: Keep task information available for follow-up.
The important distinction is that the AI should assist with decisions, not make arbitrary commitments on the user’s behalf.
A task marked urgent should not automatically be scheduled during an existing class or research meeting. A misunderstood deadline should not silently become a calendar event.
The model interprets. The application validates. The user stays in control.
Why Arduino UNO Q?
I wanted to explore something beyond another productivity application that depends entirely on a cloud-hosted AI service.
That is why I chose the Arduino UNO Q as the target hardware.
Its Linux-capable computing environment and microcontroller platform make it an interesting foundation for experimenting with local AI, application services, and physical interaction in one device.
SlowSloth is designed around three connected ideas:
1. Local AI
Gemma 3 1B is the selected model for exploring natural-language task interpretation on the device. Actual on-board inference, including its memory requirements and latency, still needs to be verified.
2. Task organisation
A backend manages task information and is intended to coordinate task interpretation, priorities, scheduling decisions, and reminders.
3. Physical interaction
The built-in LED matrix gives the assistant a potential presence on my desk, allowing reminders to extend beyond a conventional web dashboard.
This combination introduces practical engineering questions. Can the selected model run within the board’s resource limits? How quickly can it interpret a request? Can task information remain reliable when external services are unavailable? Can a reminder trigger at the correct time?
These are the questions that make SlowSloth an interesting edge-AI project rather than simply another chatbot interface.
Meet the sloth that reminds me 🦥❤️
One of the features I’m particularly excited about is the physical reminder display.
Most task managers rely on phone, browser, or computer notifications. Those notifications can be easy to miss when I’m concentrating on something else.
SlowSloth is designed to use the Arduino UNO Q’s built-in 8 × 13 LED matrix as a small visual reminder.
The goal is to give the assistant a recognisable presence on my desk: a little sloth that can catch my attention without requiring me to keep checking another screen.
SlowSloth’s visual identity: a small physical display designed to make reminders more tangible.
How the reminder is intended to work
The planned sequence is deliberately simple:
- Ten minutes before a task or event: Display the sloth face, followed by a heartbeat animation.
- One-time alert: Run the sloth-and-heartbeat sequence once for that upcoming task or event.
- No repeated pre-alert: The sequence does not keep blinking throughout the remaining ten minutes, and it is not repeated at the scheduled time.
The purpose is to provide a gentle cue that gives me time to finish what I’m doing and prepare for the next commitment.
The static sloth-face display has been tested on the Arduino UNO Q. Connecting the animation to the actual reminder scheduler and verifying its timing and behaviour with tasks and Google Calendar events remain integration work.
I want the physical interface to be more than a decorative animation. Ultimately, it should be connected to the same reliable task and reminder lifecycle as the rest of the application.
How SlowSloth is built
SlowSloth combines a web-based task-management application, an AI interpretation layer, local persistence, and a planned calendar workflow.
| Component | Purpose |
|---|---|
| Arduino UNO Q | Target hardware for local services and the physical display |
| Gemma 3 1B | Selected model for local task interpretation |
| FastAPI | Backend API |
| SQLite | Local task persistence |
| HTML, CSS and JavaScript | Web-based interface |
| Google Calendar integration | External calendar synchronisation when authorised |
| 8 Ă— 13 LED matrix | Sloth display and intended physical reminders |
The architectural principle is to separate language-model interpretation from task execution.
For example, the model may identify three tasks in one sentence and suggest that one is urgent. The application still needs to validate the extracted information, check relevant scheduling constraints, and obtain confirmation before executing consequential actions.
This separation matters because a language model can misunderstand a date, omit an important detail, or suggest a priority that does not reflect the user’s actual needs.
Running a one-billion-parameter model on an edge device also requires careful attention to quantisation, memory consumption, inference speed, context length, and runtime compatibility. These characteristics must be measured on the actual board rather than assumed from workstation performance.
Google Calendar: Turning tasks into commitments
A task list tells me what I need to do. A calendar helps me understand when I can do it.
That is why Google Calendar is an important part of SlowSloth’s intended workflow.
When configured and authorised, the integration is designed to connect approved scheduling decisions to calendar events.
The intended process is:
- Interpret the task description.
- Extract individual tasks and relevant details.
- Review priorities, deadlines, and existing commitments.
- Propose suitable scheduling options.
- Let the user confirm the intended action.
- Synchronise approved events with Google Calendar.
- Keep task information available locally for follow-up.
Local task management and external calendar synchronisation should remain separate. A task should not disappear simply because the user has not connected Google Calendar or because synchronisation encounters an error.
Google Calendar is an external service, so connecting it requires OAuth configuration and user authorisation. Live account synchronisation, event creation and updates, retry behaviour, and scheduling against real calendar availability need end-to-end verification before the complete workflow can be considered finished.
Local-first AI and privacy
Personal notes can reveal much more than a simple to-do list. They may contain research plans, examination schedules, unfinished projects, and commitments involving other people.
I wanted to explore whether an AI assistant could help manage this information without making a hosted AI provider a mandatory part of every interaction.
Using Gemma 3 1B as the selected local model provides a path towards on-device inference.
What local inference can offer
When task interpretation happens locally, task text does not need to be sent to a remote AI inference service for that operation.
Local inference can also provide opportunities to experiment with model quantisation, inference runtimes, and resource usage on hardware under the user’s control.
However, local-first does not automatically mean completely offline. Google Calendar still uses Google’s services when synchronisation is enabled, and any other external integrations must be evaluated separately.
Gemma’s model licence and terms also apply. Open weights provide opportunities to inspect and run a model, but they do not mean every possible use is unrestricted.
For this project, the objective is not to claim that local models are always better than hosted models. It is to explore a practical alternative that offers greater control over where task information is processed.
What makes SlowSloth different?
I see SlowSloth as an attempt to connect several parts of personal productivity that are often handled separately.
Natural-language task entry: Reduce the manual effort involved in turning a thought into structured tasks.
User-controlled scheduling: Propose actions without blindly executing every model response.
Physical reminders: Bring the reminder experience onto the Arduino UNO Q’s LED matrix.
Local-first AI direction: Explore task interpretation on hardware under the user’s control.
A real everyday problem: Evaluate whether the system reduces administrative effort, rather than judging it only by the quality of generated text.
The ultimate measure of success is not how many AI features the application contains. It is whether the application helps people spend less time organising work and more time doing it.
Current status: What works and what comes next
I want to distinguish between components that have been tested and features that still need integration or verification.
Tested or reported in development
- Static sloth-face display on the Arduino UNO Q.
- Automated application tests reported as passing in the development environment.
Still to verify or complete
- Gemma 3 1B inference on the actual Arduino UNO Q.
- On-board inference latency and memory consumption.
- Task extraction and priority handling with realistic inputs.
- Live Google Calendar synchronisation and event updates.
- Scheduling against real calendar commitments and deadlines.
- Integration of the one-time, ten-minute-before LED reminder with the task scheduler.
- Reminder behaviour when tasks change, are cancelled, or become overdue.
I do not want to claim a time-saving percentage without measuring it.
A useful evaluation would compare the time required to create and organise several tasks manually with the time required to enter the same information, review SlowSloth’s proposed plan, and confirm the result. The evaluation should also check for missed tasks, incorrect deadlines, scheduling conflicts, and failed reminders.
That would provide evidence of whether the assistant actually reduces administrative effort.
Quick demo video 🎥
Here is the video walkthrough of SlowSloth:
The most useful demonstration is one that shows the real application and hardware, with each capability identified accurately. Features that remain under development should be presented as planned integrations rather than completed functionality.
Explore the code and contribute
Repository
SlowSloth 🦥
Think Less About Tasks. Let Your Sloth Handle the Sorting.
SlowSloth is a local-first personal AI task-management assistant designed for busy students and people juggling multiple commitments. It aims to turn natural-language thoughts into organised tasks, help prioritise work, and schedule approved events through Google Calendar.
Built for the Arduino UNO Q, SlowSloth is designed to use Google's open-weight Gemma model family, with Gemma 3 1B selected for local task interpretation. The project brings together task planning, calendar integration, reminders, and a physical LED-matrix experience.
The motivation is personal. Between hackathons, research, courses, workshops, competitive exams, social volunteering and time with family and friends, managing commitments can become a job of its own. Recording tasks, assigning priorities, tracking deadlines, and arranging schedules takes time away from the work itself.
SlowSloth aims to reduce that administrative effort.
Capture a thought. Let your assistant organise it. Review the…
SlowSloth is an ongoing open-source project, and contributions and feedback are welcome.
Areas where engineering feedback would be particularly useful include:
- Running small language models on resource-constrained hardware.
- Natural-language task extraction and validation.
- Priority-aware scheduling and calendar conflict handling.
- Reliable reminder delivery and recovery.
- Connecting application events to the Arduino UNO Q’s LED matrix.
Please consult the repository’s current README, setup scripts, dependencies, and tests for the latest implementation details.
The payoff: More living, less organising 🦥
I don't think the answer to a busy life is necessarily to become better at maintaining more productivity systems.
Sometimes, the answer is to make those systems require less maintenance.
I want to participate in hackathons without losing track of research. I want to prepare for exams without forgetting volunteering commitments. I want to work on projects and still have time for the people around me.
I don't want to spend my entire day maintaining a record of everything I need to do.
I want an assistant that can help me remember the work, organise the next steps, and give me more mental space to do it.
That is the idea behind SlowSloth.
I'm building it for the student who has five things to finish, three new ideas in their head, and absolutely no desire to open another app just to write them all down.
Let the sloth handle the planning. You handle the living. 🦥
Top comments (0)