cloudy! : keychain companion ai that works on your behalf.

Cloudy as a keychain
Cloudy, sleeping
Minimal Landing Page
Docs
Dashboard
MCPs to connect
MCPS
Cloudy as a hanging accessory in my friend's pants

Inspiration

Whenever my AI agents were working and needed a human-in-the-loop approval, I had to open my laptop or pull out my phone, find the right app, understand the context, and click a button.

The frustrating part was that most of these decisions only took a few seconds. Approve the plan. Merge the pull request. Send the drafted reply. Roll back the broken deployment. Reaching the decision often took longer than making it.

That made us wonder: what if these quick but important decisions could come directly to a small companion that was always with you?

That idea became Cloudy, an AI-powered keychain companion that gives you the context you need, lets you approve or reject the action, and gets you back to whatever you were doing.

What it does

Cloudy turns important events from your agents and connected tools into simple, glanceable Pings.

A Ping could be an email that needs a reply, a GitHub pull request ready to merge, a deployment that should be rolled back, or a Codex plan waiting for approval.

Cloudy first shows a short summary with the important context. If you need more information, you can open the details page and scroll through the complete request.

You can:

Review important notifications without opening your laptop
Read the complete context behind a request
Approve or reject an action
Dictate a revision to an AI-generated plan
Move between different apps and notification feeds
Continue viewing cached information when the network drops

Cloudy is not trying to replace human judgment. It lets agents do the preparation while keeping you in control of important decisions.

How we built it

The physical prototype uses a Raspberry Pi Zero 2 W connected to a 2.8-inch SPI touchscreen. The display uses an ILI9341-compatible controller, and touch is handled by an XPT2046-compatible controller.

The interface is written in Python with Pygame and renders directly to the Linux framebuffer. This helped us get a sharp native image without running a complete desktop environment on the Pi.

We built the dashboard using Next.js. From the dashboard, users can connect services, configure Pings, control the physical screen, and test realistic scenarios for Gmail, GitHub, deployments, and Codex.

The backend uses Hono with Supabase for authentication, data storage, and realtime updates.

Cloudy uses authenticated server-sent events and Supabase Realtime broadcasts instead of continuously polling the backend. When something changes, the keychain receives a lightweight signal and fetches the latest authoritative snapshot.

Approvals, rejections, and other important commands still use authenticated HTTP requests. This keeps decisions explicit, secure, and easy to verify.

Challenges we ran into

Hardware was easily the most humbling part of the project.

At different points, the display was white, blurry, rotated incorrectly, or showing a cursor in the middle of the interface. The touch controller was even more sensitive because the display and touch share parts of the SPI bus while still needing separate chip-select and interrupt connections.

Designing for a 2.8-inch display was another challenge. Text that looked perfectly readable on a laptop became tiny on the physical screen. We spent a lot of time adjusting font sizes, margins, wrapping, scrolling, and the amount of information shown on each page.

Realtime communication also took some work. Our first version polled the backend every two seconds. It worked, but it was wasteful and never felt truly immediate. We replaced it with realtime invalidations, reconnect handling, cached state, fallback polling, and periodic safety refreshes.

We also ran into interaction bugs that only appeared on the real device. For example, if someone pressed Scroll Down while the details-opening animation was still running, the command could be ignored because the screen still considered itself to be on the summary page.

These were small problems individually, but fixing them made Cloudy feel much more reliable and natural.

Accomplishments that we're proud of

We are proud that Cloudy became more than a small display showing hardcoded notifications.

The keychain now connects to a real backend, receives realtime updates, survives temporary network failures, and routes decisions through authenticated API paths.

We built realistic flows for:

Reviewing and merging a GitHub pull request
Reading an email and approving a drafted response
Responding to a risky deployment with a recommended rollback
Reviewing a Codex implementation plan
Dictating a revision before approving an agent’s work

We are also proud of how calm the interface feels. Cloudy shows the most important information first, then lets you ask for more. It does not try to squeeze an entire dashboard onto a tiny screen.

Most importantly, the final decision still belongs to the person carrying it.

What we learned

We learned that building a useful AI product is often less about generating more information and more about choosing what not to show.

A short and trustworthy summary can be more helpful than a perfect wall of text. A recommended action is only valuable when the user can inspect the context behind it.

We also learned that realtime systems need good offline behavior. A device should not become useless just because the network disappears for a few minutes.

Physical interfaces expose every rough edge. Latency, font size, animation timing, unclear states, and small wiring issues become immediately obvious when the product is sitting in your hand.

The biggest lesson was that AI agents feel much more useful when they have clear boundaries. Cloudy lets agents gather context, prepare actions, and suggest the next step, while keeping important approvals intentional and human.

What's next for cloudy!

Our next goal is to turn the prototype into a genuinely portable keychain companion that works on your behalf.

We want to make the hardware smaller, improve battery life, create a proper enclosure, and move from jumper wires to a compact custom board.

On the software side, we want Cloudy to understand personal priorities and learn which events are actually worth interrupting you for.

Low-risk and repetitive tasks could be completed automatically using rules you control. Important actions would still ask for approval and show the exact context behind the decision.

We also want to add more integrations, improve voice interaction, support secure production hosting, and build better end-to-end encrypted personal context.

The long-term vision is simple: Cloudy stays close, keeps track of what matters, and helps your agents move work forward without forcing you to constantly open your laptop or phone.