This is a submission for the Hacktoberfest Open-Source AI Challenge Week 3: Slow and Steady
🦥 Flash: The Sloth Who Outsmarted a Fox
Celebrating laziness through Disney’s favorite sloth — one automated task at a time.
ZPD Headquarters. 9:00 AM.
Nick Wilde: (leaning back in his chair, spinning a pen between his fingers) “Well, well, well. If it isn’t Officer Hopps. Still doing everything manually? Spreadsheets, browser searches, reports... Carrots, I thought rabbits were supposed to be fast.”
Judy Hopps: (without looking up from her screen) “And I thought foxes were supposed to be clever, Nick. Yet here you are, wasting everyone's time.”
Nick: “Ouch. Anyway, I've got a little challenge for you. Compile this week's expense report, check three websites, organize the evidence, and prepare a briefing. You've got five minutes.”
(He drops a mountain of files onto her desk.)
Nick: “Let's see if those famous rabbit reflexes can beat a fox who already finished his coffee.”
Judy: (examining the files calmly) “You know, Nick, speed isn't the same as intelligence. And doing everything yourself isn't the same as being productive.”
(She opens Flash.)
Judy: “Flash, prepare the expense spreadsheet, organize my notes, and research these websites. Keep the original evidence untouched.”
Flash Slothmore: (slowly raises his head, blinks twice, and smiles) “Absoooooo-lutely.”
Nick: “Wait. You're trusting a sloth with a deadline?”
Judy: “I'm trusting a system I've designed to do the repetitive work, with boundaries I've chosen and results I can verify.”
(A few moments later, the spreadsheet is formatted, the notes are organized, and the browser research is ready for review.)
Nick: (staring at the screen) “That's... not possible. I haven't even finished my second coffee.”
Judy: “Maybe next time, Nick, you'll spend less time showing off and more time thinking.”
Flash: (smiling at his completed task list) “Have... a... nice... day.”
Nick Wilde: 0. Judy Hopps: 1. Flash: still not in a hurry.
🦊 Lesson learned: Never underestimate a rabbit with a plan and a sloth with an automation pipeline.
What I Built
Meet Flash — a local-first AI desktop companion inspired by Flash Slothmore, the unforgettable DMV sloth from Disney's Zootopia.
Most AI assistants are designed to answer questions. Some can call tools. Flash takes the next step: it helps turn natural-language instructions into practical desktop actions, from creating office documents to organizing checklists and automating browser workflows.
The goal is simple: let AI handle the repetitive work while humans stay in control of the important decisions.
Flash is built around an open-weight language model running locally, native Windows automation, a web companion, and a cloud coordination layer.
Think of it as a tiny sloth-powered productivity department that never asks for a coffee break.
What can Flash do?
1. Control native Windows applications
Flash can launch applications and interact with supported Windows interfaces using Python automation tools, including pywinauto and Windows UI Automation.
It can handle tasks such as opening Notepad, entering dictated notes, and interacting with supported application controls. Instead of relying entirely on brittle screen coordinates, it can inspect accessible UI elements where supported.
2. Generate real office documents
Flash can create useful files directly in its local workspace:
-
.xlsxspreadsheets for expenses and other structured data. -
.docxdocuments for notes and reports. -
.pptxpresentations for briefings and slide decks.
No need to start from a blank document and spend ten minutes formatting column headers. Flash is happy to do the boring bits.
3. Accept voice-driven tasks and checklists
The companion interface supports voice dictation and task management, making it easier to add groceries, capture reminders, and organize everyday chores.
Instead of manually typing a shopping list on a tiny phone keyboard, you can simply tell Flash what you need.
4. Automate browser workflows
Using Stagehand and Browserbase, Flash can interact with supported websites, observe page elements, perform actions, and extract information for research tasks.
This makes repetitive browser work easier to structure into reusable workflows instead of manually jumping between tabs.
5. Connect a mobile-friendly companion to a local agent
The web companion is hosted on Render, while a separate Python agent runs on the user's Windows machine.
A pairing flow connects the two components without giving the cloud coordinator direct access to the desktop.
The important distinction: Flash's local desktop automation is designed to run on the Windows machine. Cloud-hosted browser sessions, online voice services, and other external integrations still require their respective network connections.
Demo
🌐 Live Web Companion: https://flash-cloud-coordinator.onrender.com/
🛡️ Security Boundary & Architecture: https://flash-cloud-coordinator.onrender.com/about
🐙 Source Code: https://github.com/SK-Sathyavada-008/flash
Open the live companion to explore Flash's animated sloth interface, voice-dictation experience, and interactive demo.
The companion includes cursor eye-gaze tracking and idle animations that give Flash a little personality. You can also explore the pairing flow for connecting to the local PC agent.
A note about the demo: The hosted companion demonstrates the web experience. Actual native Windows automation requires the local agent to be installed and running on a compatible Windows machine.
How I Built It
Flash combines local AI inference, deterministic command handling, Windows automation, browser tooling, and a cloud-hosted web companion.
The architecture is intentionally split into three layers.
1. The architecture
flowchart TD
A["Mobile / Web Companion"] --> B["Render Cloud Coordinator"]
B -->|"Paired connection"| C["Local Windows Agent"]
C --> D{"Command Router"}
D -->|"Known commands"| E["Deterministic Fast Path"]
D -->|"Natural language"| F["Ollama + Gemma 2:2B"]
E --> G["Validated Task Execution"]
F --> G
G --> H["Windows UI Automation"]
G --> I["Office File Generation"]
G --> J["Local Checklists & Notes"]
G --> K["Stagehand + Browserbase"]
C --> L["Voice Output"]
C --> M["Logging & Error Tracking"]The key design choice is that the local agent is responsible for desktop actions. Render hosts the companion and coordination service; it does not need direct desktop privileges to serve the web application.
2. Local intelligence with Gemma 2:2B
Flash uses Google's Gemma 2:2B, an open-weight language model, through Ollama.
Rather than sending every command to a remote language-model API, Flash uses a hybrid approach:
- Deterministic fast path: Recognizes supported, predictable commands such as opening an application.
- Local model inference: Routes more ambiguous natural-language instructions to Gemma for intent interpretation and parameter extraction.
- Structured output: Uses constrained instructions and JSON-oriented parsing to make model outputs easier to validate.
- Fallback parsing: Provides a rule-based alternative for supported commands when Ollama is unavailable.
The fast path avoids the overhead of model inference for commands that do not need it. The local model handles the more flexible language-understanding work.
Gemma does not need to be the fastest model in the city. It needs to be useful, available locally, and predictable enough to fit into a carefully designed workflow.
3. Native Windows automation
Flash uses Python-based Windows automation, including pywinauto and Windows UI Automation, to interact with supported applications.
The local agent is responsible for:
- Launching applications.
- Interacting with accessible interface elements.
- Entering text and executing supported actions.
- Creating and organizing files in the local workspace.
Separating command interpretation from execution makes it easier to validate instructions before carrying them out.
A language model can interpret what a user wants, but the automation layer should determine which actions are actually supported.
4. Office file generation
Flash generates real files instead of merely describing how to create them.
Python document-generation libraries handle the structured output, including spreadsheets, Word documents, and presentations.
This is a useful example of why an AI application does not need to use a language model for everything. Gemma interprets the request; deterministic code handles the formatting and file creation.
The result is a practical combination of flexible language understanding and conventional software engineering.
5. Voice: ElevenLabs and offline fallback
Flash integrates ElevenLabs for neural text-to-speech, giving the companion a more expressive voice.
For supported local speech-output workflows, Windows SAPI through pyttsx3 provides an offline fallback.
This distinction matters: the local speech fallback can work without an internet connection, but ElevenLabs and other cloud services still depend on connectivity.
The result is a voice experience that can degrade gracefully instead of treating a network outage as the end of the world.
6. Browser automation with Stagehand and Browserbase
Flash integrates Stagehand's browser automation primitives — act, observe, and extract — with Browserbase-hosted browser sessions.
These tools can help Flash interact with websites, inspect page content, and extract relevant information.
The browser component is separate from the local Windows automation component. Because Browserbase runs browser sessions in the cloud, those workflows require network access and should be treated separately from local-only operations.
7. Render, MongoDB Atlas, and observability
The remaining infrastructure makes Flash easier to deploy and operate:
- Render: Hosts the web companion and cloud coordination service.
- MongoDB Atlas: Supports persistent storage for routines, checklists, and preferences, with local JSON fallback where configured.
- Sentry: Supports error reporting and observability for troubleshooting agent operations.
Together, these services make Flash more than a local script. They provide a path toward a usable companion with a web interface, persistent data, and operational visibility.
Why Does Open Innovation Matter?
Flash is built around a simple belief:
An AI assistant that can operate your computer should not require you to hand over every part of your digital life to a closed API.
Open innovation matters here for three main reasons.
1. Local control over private desktop tasks
A desktop assistant may interact with documents, notes, spreadsheets, and application windows containing sensitive information.
Running Gemma locally through Ollama allows supported language-model inference to take place on the user's machine. Those prompts do not need to be sent to a hosted LLM provider.
That gives users more control over where their desktop context is processed.
However, local inference alone does not make the entire application offline or guarantee that every component is private. Flash's cloud coordination, Browserbase sessions, ElevenLabs integration, and remote storage can involve external services. Keeping those boundaries explicit is part of designing a trustworthy system.
2. Less dependence on per-token pricing
A local model can interpret supported tasks without incurring a hosted LLM API charge for every request.
For an assistant that might be invoked throughout the day, that can make a meaningful difference.
Local inference is not literally free: the computer consumes electricity, hardware has costs, and external services may have their own pricing. But it gives users an alternative to making every interaction dependent on paid model inference.
3. Freedom to experiment and improve
Open-weight models give developers more control over how inference is deployed and integrated.
With Gemma and Ollama, I can experiment with prompts, change the command-routing logic, adjust structured-output handling, and test local inference without redesigning the whole application around a proprietary model API.
I can also separate the model from deterministic execution logic, making it easier to test and replace individual components.
That is what open innovation makes possible: not just using AI, but understanding how it fits into a system and having the freedom to change that system.
The Lazy Payoff
Let's revisit Judy's challenge.
Nick thinks productivity means doing everything himself, moving quickly, and making sure everyone notices.
Judy knows better. The real advantage comes from identifying repetitive work, choosing the right tools, and checking the results.
| Task | The manual way | The Flash way |
|---|---|---|
| Grocery checklist | Unlock phone, open notes, type every item | Dictate supported items and organize the checklist |
| Expense spreadsheet | Open Excel, create headers, format rows | Request a spreadsheet and let the local agent generate it |
| Meeting notes | Open an editor and type everything manually | Dictate notes into a supported local workflow |
| Web research | Switch between tabs and repeatedly inspect pages | Use a browser automation workflow to interact with and extract information |
| Desktop chores | Repeatedly open applications and perform routine steps | Delegate supported actions to the local agent |
The precise time saved depends on the task, hardware, network conditions, and how much review is needed. The goal is to eliminate repetitive manual steps, not pretend every task can be completed instantly.
And Judy never blindly trusts the output. She checks the spreadsheet, verifies the research, and keeps control over important decisions.
That is the difference between useful automation and letting an AI loose on your computer and hoping for the best.
Flash does the repetitive work. Judy makes the decisions. Nick gets humbled.
Honestly, that sounds like a pretty good productivity strategy.
Prize Categories
I'm submitting Flash for the following categories, where the corresponding integrations and implementation meet the challenge requirements.
🏆 Overall Challenge: Slow and Steady
Flash embodies the theme by using open-weight AI and desktop automation to reduce repetitive work and let people reclaim their time.
🌟 Featured Categories
Best Use of Gemma — $200
Gemma 2:2B runs locally through Ollama and supports natural-language intent interpretation and structured parameter extraction in Flash's command pipeline.
Best Use of Render — $200
Render hosts the public web companion and cloud coordination service, connecting the web experience to the separately running local agent.
🤝 Partner Categories
Best Use of ElevenLabs — $100
ElevenLabs provides neural voice output, with a Windows SAPI fallback for supported local speech workflows.
Best Use of Browserbase — $100
Browserbase and Stagehand power cloud browser automation for supported research and data-extraction workflows.
Best Use of MongoDB Atlas — $100
MongoDB Atlas provides persistent storage for supported routines, checklists, and preferences, alongside local fallback storage.
Best Use of Sentry Agent Tracing — $100
Sentry integration supports operational visibility and troubleshooting for agent errors and execution behavior.
What's Next for Flash?
Flash is a starting point for exploring how local-first AI can make desktop automation more approachable.
Some directions I'd like to explore further include:
- More robust task planning and execution reporting.
- Clearer approval boundaries for sensitive desktop actions.
- Better recovery when an application or browser workflow fails.
- More detailed performance measurements for local inference and command execution.
- Expanded offline workflows that reduce dependence on cloud services.
- More reproducible tests for command parsing, file generation, and UI automation.
The aim is not to build an AI that does absolutely everything. It is to build one that does the boring things reliably, explains what it did, and leaves the user in control.
Final Verdict: The Fox Lost. The Rabbit Won. The Sloth Went Back to Work.
Nick Wilde: “Okay, I'll admit it. That sloth is surprisingly useful.”
Judy Hopps: “And what have we learned today, Nick?”
Nick: “Never challenge a rabbit who knows how to automate?”
Judy: “Close enough.”
Flash: (slowly closing the completed report) “Can... I... go... home... now?”
Judy: “Case closed.”
Nick: “This is the worst day of my life.”
Flash: “Sounds... exhausting.”
🦥💤
Built with open-weight AI, Python, Ollama, Gemma 2:2B, Windows automation, React, Render, Stagehand, Browserbase, and a healthy respect for doing less repetitive work.
GitHub: SK-Sathyavada-008/flash
Live Demo: flash-cloud-coordinator.onrender.com
“Change starts with you.” — Officer Judy Hopps
“Yeah, but tomorrow.” — Flash Slothmore 🦥
Team
@veerrr
Top comments (0)