HomeSync

HomeSync simulates your smart home over time, catching hidden conflicts between automations — like three separately-approved rules that quietly combine to freeze your pipes.

Comment

Inspiration

Most smart-home write-ups pitch "AI that automates your home." Ours is the opposite pitch: the automation is already there, and it's already the problem. Homeowners don't run one smart-home system — they run three or four, stacked on top of each other. Apple Home for presence and security, IFTTT for the odds-and-ends integrations no single platform covers, a smart thermostat like Ecobee for HVAC scheduling. Each rule gets reviewed once, looks completely sane in isolation, and gets switched on.

None of those platforms can see what the others are doing. We got interested in what happens when you actually play three individually-reasonable rule sets forward together over a real span of time — not as a hypothetical, but as an hour-by-hour simulation. The scenario we built around (a 72-hour winter trip where an energy-saver rule, an air-quality rule, and an away-mode rule combine to put a water line at real risk) is exactly the kind of failure that's invisible to every existing platform, because the failure isn't in any one rule — it's in the combination.

What it does

HomeSync imports the automations a homeowner already has across three ecosystems — Apple Home, IFTTT, and Ecobee — shown the way a homeowner would actually encounter them, each already marked "reviewed ✓." It then runs a deterministic simulation engine that plays every rule's trigger/action forward, hour by hour, across a 72-hour scenario, and detects the cross-cutting physical consequence that none of the three rules individually encodes: indoor temperature drifting toward freezing while a fresh-air vent stays open and the furnace is capped, right next to a water line.

Once that conflict is detected with certainty, a local LLM explains it — in one paragraph of plain, jargon-free homeowner language — what's about to happen physically and why none of the three rules caught it on their own. A scrubbable timeline and a live house cross-section let you watch the state evolve, with the conflict moment highlighted. And one leg of the demo isn't simulated at all: when the conflict-causing rule actually fires, HomeSync sends a real HTTPS webhook to your own IFTTT account.

How we built it

The frontend is React + TypeScript + Vite + Tailwind, with dedicated components for the ecosystem rule panels, the house schematic, the scrubbable timeline, and the AI narrative log. The backend is Node.js + Express, exposing /api/scenario, /api/simulate, and /api/ifttt/*.

The core of the project is a pure-JavaScript deterministic state-machine engine with zero dependencies — it's the single source of truth for what physically happens in the house, and it never touches an LLM, so the simulation itself can't hallucinate or flake mid-demo. On top of that sits a narrative layer that calls a local Ollama model (deepseek-r1:1.5b) with a tightly bounded job: given a conflict the engine has already detected with certainty, produce a 3–4 sentence, non-technical explanation of what's happening and why. If Ollama isn't reachable, the app falls back to a deterministic template explanation instead of breaking. Finally, we wired up real IFTTT Maker Webhooks — when the "Fresh Air Vent Rule" fires during a simulation, the backend makes a genuine HTTPS call to the user's own IFTTT account and surfaces IFTTT's real response, success or error, in the UI.

Challenges we ran into

Keeping the LLM in its lane was the hardest design problem, not a technical one. It would have been easy to let the model "figure out" the conflict itself, but that turns the core insight into something un-demoable and unreliable. We deliberately split the system so the LLM only ever narrates a fact pattern the deterministic engine has already computed — which meant writing a prompt tight enough that a 1.5B local model stays useful without wandering into invented physics.

deepseek-r1 also emits <think>...</think> reasoning before its actual answer, which we had to strip server-side so homeowners only ever see the plain-language conclusion. On the integration side, IFTTT gates the realtime "Receive a web request" trigger behind IFTTT Pro, so a free-tier account gets a real 401/403 back — we chose to surface that honestly in the UI rather than fake success. And Apple HomeKit turned out to be structurally out of reach for a backend project: there is no server-side HomeKit API at all, so reading a user's real Apple automations would require a native Swift companion app, which we scoped out rather than fake.

Accomplishments that we're proud of

We're proud that the riskiest-looking part of the demo — the physics — is the part that can't fail live, because it's a real, tested state machine rather than anything probabilistic. We're also proud that one leg of the integration is genuinely real: a live HTTPS call to a real IFTTT account, not a mocked response. And we tried hard to be upfront about scope rather than oversell it — the README includes an explicit "What's real vs. simulated" section explaining exactly what's live today, what's structurally out of reach (HomeKit), and what's deferred but real-API-backed (Ecobee OAuth).

What we learned

We came away with a much sharper sense of how fragmented the smart-home ecosystem actually is at the API level — HomeKit's total lack of a server-side surface versus Ecobee's real but OAuth-gated API versus IFTTT's tier-gated realtime triggers are three completely different integration realities, not just three different SDKs. We also learned a lot about designing an LLM's role by subtraction: the narrative layer got better every time we removed a decision from it, not every time we gave it more context.

What's next for HomeSync

  • Real Ecobee integration via its OAuth PIN flow, as the second fully-live ecosystem alongside IFTTT.
  • A native iOS companion app for genuine Apple HomeKit automation import, since that's the only way to read real HomeKit automations.
  • More scenarios beyond the winter pipe-freeze case — security gaps, spoiled food, locked-out arrivals — using the same deterministic-engine-plus-bounded-LLM pattern.
  • A general conflict library, so any imported rule set can be checked automatically instead of relying on one hardcoded scenario.

Presentation Deck

View the Presentation Deck

Built With

Share this project:

Updates

Submission history