A kitchen-mounted family calendar dashboard, coordinated by an always-on home agent.
Most shared calendars solve the wrong problem. They let two people put events into the same place. They do not, at a glance, let either person walk into the kitchen and instantly know what the day looks like for both of them — or what the week ahead is shaping up to be.
This project closes that gap. A repurposed iPad, mounted on a custom wooden stand on the kitchen island, displays a single-purpose dashboard that shows today's schedule for both partners side by side, a weekly overview, and a running list of household notes. It updates automatically. It requires no interaction. It just sits there, doing its job, like a piece of furniture.
The dashboard is served from a Mac Mini that already lives in the home as part of an always-on personal agent system. The agent — internally called Orion — handles the calendar synchronization, runs the web server, and will eventually manage the notes section through a chat interface. The result is a system that is both more useful and more durable than anything available off the shelf.
The premise is mundane. Two adults in a household, each with their own Google Calendar, each with their own working rhythms, each occasionally needing to know what the other's day looks like — for dinner timing, school pickup logistics, surprise free hours, or simply to ask "how's your day?" with some grounding.
Google Calendar's overlay feature technically solves this. In practice, it solves it badly. It requires opening an app, picking a date, mentally filtering by color. The friction is small, but small friction multiplied by daily use is its own kind of cost. The information needs to be ambient — visible without effort, present without demanding attention.
The brief, then, was simple: a glanceable display, mounted somewhere both partners pass through, showing the day's plan for both of them at once. No interaction required. No login. No app to open. Just a piece of the kitchen.
The core insight that made this build clean rather than complicated was leveraging an existing piece of home infrastructure: a Mac Mini that runs a personal agent system 24/7. The agent — Orion — already had its own Google account, its own credentials, and its own role as a coordination hub for various household automations.
This changed the architecture from "build a calendar integration" to "share both calendars with the entity that already exists to coordinate them." Both partners shared their Google Calendars with Orion's account, granting it read access. Orion now had a unified view of both schedules and could serve them through a simple Express endpoint on the local network.
The dashboard is a React frontend served as a Progressive Web App from the Mac Mini. The iPad — a dusty 6th generation unit retrieved from a drawer — points to a local IP, was added to the home screen, and now runs in fullscreen kiosk mode using iOS Guided Access. No external dependencies. No cloud services beyond Google Calendar itself. No exposure to the public internet.
Notes are stored as a flat JSON file on the Mac Mini. The dashboard polls them every two hours, alongside fresh calendar data. The two-hour cadence is deliberately slow — a kitchen display does not need real-time updates, and a slow refresh cycle reduces visual disturbance for anyone glancing at it.
The implementation work was handed off to the same agent that would eventually run the system. After the design and architecture were finalized, the entire build process — scaffolding the project, writing the Express backend, setting up Google Calendar API authentication, building and serving the React frontend, configuring the PWA manifest, and managing the long-running process — was packaged as a single structured handoff document and executed autonomously.
This is a pattern worth naming explicitly. The work breaks into three distinct roles:
Decisions about what the system should do, how it should look, and what tradeoffs are acceptable. Done by the human, in collaboration with a thinking model.
Mechanical steps to bring the design into existence and keep it running. Delegated to the home agent, which already lives on the target machine.
The handoff document acts as the interface between these two roles. It contains the full intent, the architecture decisions, the code, and the verification criteria — everything needed for an agent to execute without needing to ask questions. Written once, executed once, and subsequently used as the system's own documentation.
The dashboard does one thing. There is no configuration screen, no theme picker, no view that can be lost. It cannot be broken by a misplaced tap because there are no taps that matter.
The palette is sepia and parchment, not white and gray. A kitchen is a warm room with warm light. A cold blue interface feels alien against wood, ceramic, and food. The display should belong.
Louis's events use sage green; Jen's use terracotta. The columns are visually anchored at the top with these colors so identity is established before any text is read. From four feet away, you know whose day you're looking at instantly.
Updates happen quietly every two hours. There are no spinning loaders, sliding transitions, or notification badges. A kitchen display that demands attention is a failed kitchen display.
Everything runs on the home network. The agent's Google account is the only entity bridging to external services. If the internet goes down, the dashboard still shows the last-fetched schedule. If Google's API changes, only the agent needs updating.
A dashboard is only as useful as its placement. An iPad lying flat on a counter is invisible; one propped against a backsplash blocks usable surface area. The solution was a custom wooden stand, hand-built to sit on the kitchen island, holding the iPad at a slight tilt and at the right height to be glanceable while standing or seated.
The stand was made from a single piece of walnut, with a recessed cradle for the iPad and a cable channel running through the back to keep the charging cord out of view. It treats the iPad less like a piece of consumer electronics and more like a framed photograph. The materiality matters: against the warm sepia of the dashboard interface, the wood becomes part of the aesthetic continuity rather than a contrasting element.
This is, perhaps, the most important detail of the whole project. Software that lives in the physical world should be designed for the physical world. The dashboard's color palette was chosen because it would coexist gracefully with wood and warm light. The screen is mounted in furniture-grade material because it is, functionally, a piece of furniture. The system is not just a calendar; it is a small contribution to the room.
Three patterns emerged that are worth carrying forward into similar builds.
Existing infrastructure changes the math. The Mac Mini was already on, the agent was already running, the Google account already existed. None of it had to be created for this project. When considering a new home automation, the first question is not "what should I build" but "what is already running that could absorb this?" Most household needs do not justify their own server. They do justify their own endpoint on a server that is already there.
The hardest part is restraint. The instinct to add features — weather, news, traffic, smart home controls — is constant and must be resisted. Each addition would degrade the dashboard's usefulness as a calendar by competing for attention. A specialized tool, well-executed, beats a multi-purpose tool every time.
Design through to the physical artifact. The dashboard's interface and the wooden stand were designed together, in the same week, with the same palette in mind. The interface knows it lives in a kitchen; the stand knows it holds a calendar. This kind of coherence is impossible to achieve when interface and hardware are designed by different parties — which is to say, it is the rare gift of building things for yourself.