This is a submission for the Hacktoberfest Open-Source AI Challenge Week 2: Side Hustle.
What I Built
I build software for clients, and AI agents have become part of that work. Keeping track of several sessions introduces a surprisingly ordinary problem: which one is working, which one is waiting, and which one needs me to make a decision?
I wanted a useful answer at a glance. I also wanted it to be a little fun.
Miilo gives your AI workflows a tiny robot crew. Each robot represents an observed system or group of sessions. Working robots move, resting robots close their eyes, and a ?! makes a request for attention hard to miss. Their colors follow your launcher theme.
In Compact, the crew fits into a small space. In Detail, you can see the tasks behind each system. Select a task to inspect its notes, evidence and file changes. When you need help understanding it, Explain brings a self-hosted Gemma model into the conversation.
The immediate audience is freelancers, independent developers and small teams using several coding sessions or automation systems. They need to understand what happened before they approve the next step.
The CLI, SDK, widgets and native Omarchy plugin are now public, with versioned GitHub releases and a Homebrew tap. My commercial hypothesis is that some of these users will pay for custom provider integrations, private deployment and support. Sponsorship can help fund the shared tools. Those are hypotheses I want to validate with real users, rather than invent a subscription price for the post.
Demo
End-to-end video walkthrough coming soon....
The walkthrough follows a complete journey:
- Start with an empty Miilo.
- Connect four named systems.
- Switch between Compact and Detail, then filter what needs attention.
- Open a review task and inspect its notes, check result and colored file changes.
- Ask Gemma to explain it.
- Confirm a supported approval and watch the observed state update.
The recording uses curated task fixtures with live Gemma inference. The approval shown affects an isolated demonstration provider. Existing-session observation is tested separately; the demo does not imply that every coding harness exposes approval controls.
Preview clips
These three short previews use sample systems and tasks. The separate end-to-end mobile recording will show the longer onboarding and explanation journey.
Project home: miilo.tech.
Code
The entry's main pieces are:
- Miilo CLI: standalone observation of explicitly selected existing sessions, plus optional remote connections.
- Miilo widgets: the shared robot experience, Rust helper and Omalauncher integration.
- Miilo for Omarchy: the native desktop plugin.
- Miilo SDK: the provider contracts and shared foundation.
- Homebrew tap: installation for macOS and Linux.
Install the CLI with:
brew install miilo-ai/cli/miilo
Versioned downloads are available for CLI v0.2.2, SDK v0.2.0, widgets v1.4.0, and Omarchy plugin v0.1.0. Source availability does not imply an approved marketplace or AUR listing.
The broader Miilo planning and SDK predate this challenge. During Week 2, I built the standalone observer CLI, launcher experience, native Omarchy plugin, and public website, building on that earlier foundation. The CLI repository began October 13, widgets October 14, and the separate native plugin October 16. The website is now live at miilo.tech, hosted on DigitalOcean. Many thanks to our sponsors!
Omalauncher, OWL, and the upstream Quickshell renderer provide the platform. The vendored renderer retains its upstream notices and source provenance. Miilo adds observation integration, original robot behavior, workflow inspection, and model-backed explanations.
How I Built It
Observation starts with a deliberate choice
The native local collector can observe selected existing Codex and Cursor sessions. Discovery does not start an agent or silently enroll everything it finds. Local observation can run without a Miilo account, a cloud backend or a listening HTTP service.
For remote automation, users can explicitly connect a provider endpoint. A provider can supply richer workflow state, evidence and supported actions. Local transcript activity alone does not establish authoritative approval or execution state.
Rust owns collection and helper behavior. Domain/application boundaries keep that logic separate from filesystem, HTTP, process and presentation adapters. The native CLI is complemented by a Node client; OWL and QML provide the launcher and desktop presentation.
The robots share one visual language
Compact and Detail use the same observed state. A system's robot remains recognizable as you move into its tasks.
The orbital tracks and moving lights share their geometry, so the lights stay on their paths. Sleeping systems have muted rings. Different offsets keep the crew from moving in perfect synchronization. A brief electrical zap adds personality to active work.
These effects are decorative. The task notes and evidence remain the basis for decisions. Reduced and disabled motion options are available.
Gemma explains the evidence
For the recorded explanation, I served Google Gemma 3 12B IT on infrastructure I control, using Transformers/PyTorch behind an OpenAI-compatible endpoint. The task’s Explain button calls its provider’s explanation capability; the demonstration provider delegates that request to Gemma. General text chat uses a separate configurable helper path.
The explanation path supplies bounded context for the selected task: its observed state, review notes, linked evidence and available file changes. Gemma turns that context into a short explanation.
The model does not receive authority to approve a task. Where a provider advertises an eligible action, the helper rechecks the observed revision and requires confirmation before submitting it. Changed revisions are rejected, and mutation requests are not automatically retried.
That boundary matters when the answer sounds convincing. A generated explanation is still an explanation; provider state and evidence establish what happened.
Test the actual paths
Validation included 264 official OWL tile/screen evaluations, 36 desktop scenarios, 54 exact portrait comparisons, and the plugin's 24 Node tests. Rust tests cover HTTP behavior, stale revisions and the explanation deadline.
We also clicked through the actual Android emulator. That exposed a real timing issue: a valid model response could exceed the ordinary eight-second request deadline. Read-only explanations now have a twenty-second deadline, while observation and action deadlines stay unchanged.
The published CLI artifacts were also checked on macOS, Linux and Windows, and the public Homebrew installation was validated on macOS and Linux. Installed Omarchy acceptance remains a separate host check. Voice is deferred from this release.
Why Does Open Innovation Matter?
I can choose where inference runs. Self-hosting Gemma lets me keep the explanation service on infrastructure I control. It avoids a mandatory third-party model API bill, although hardware, electricity and operation still cost money.
The model is replaceable. Users can configure an OpenAI-compatible endpoint instead of depending on my model server. Gemma is the open-weight model demonstrated here; it is not a requirement to use one particular hosted AI vendor.
The observation tools can stand on their own. A developer can use the local CLI without signing up for a managed service. Shared provider contracts give other people a way to add integrations.
These choices also make the business question more interesting: can useful open tools lead to sustainable integration and support work?
Privacy still requires care. Selected summaries and evidence can contain sensitive information. Users need to understand the context they share with a configured model; self-hosting alone is not a guarantee of security.
Development and this write-up used AI assistance. The demonstrated workflows were reviewed and exercised, including the actual emulator interaction.
My First User
Just unleashed on X/Twitter, stand by!
Prize Categories
Best Use of Gemma: Gemma 3 12B IT performs the live task explanation shown in the demo. It receives selected workflow context and evidence through an OpenAI-compatible service running on infrastructure I control.
Best Use of DigitalOcean: The public Miilo website is deployed on DigitalOcean App Platform at miilo.tech, with a DigitalOcean starter URL. The demonstrated Gemma inference runs on separate, self-hosted infrastructure.
Best Use of a .tech Domain: I claimed miilo.tech through the Hacktoberfest offer. It is now the public website address, serving the DigitalOcean deployment over HTTPS: miilo.tech.
Top comments (0)