HomeZero on Flue.
Cells, retired.

We're in the agent-hosting business by accident.

Cells gave each agent a real Linux box on a wells VM — and with it, a standing tax: VM provisioning, hibernate-recovery, the mother birth chain, a per-session model hack, and an analytical brain (Stoolap) that kept throwing vec0.so ABI errors. None of that is HomeZero. It's plumbing we maintain so the agents can run.

Flue moves the agent onto a Cloudflare Durable Object: a single-tenant, SQLite-backed, durably-executing instance that exists only when addressed and costs nothing idle. The spike proved the full stack end-to-end — a conversational agent you can chat with on the web, switch models mid-thread, all routed through the claudeflare-gateway. What follows is how the rest of HomeZero lands on that substrate.

Every cells capability has a home.

The scary row was always "the box." It turns out Flue offers a tiered filesystem — including a real per-session Linux container when you need one — so nothing forces a single migration model. The advisor runs light; the scraper, when it comes, can run heavy.

Two filesystem tiers matter: Workspace (durable files, structured code tool, no raw bash) for the advisor; Sandbox container (real shell, git, apt) reserved for agents that must shell out.

Four layers. Your existing law, renamed.

This isn't a new data model — it's the four-store law you already reasoned out (Convex / R2 / Stoolap / cell-FS), ported to the new substrate: cell FS → Workspace, Stoolap → Turso, Convex stays Convex, R2 stays R2. Sorted by access pattern, not data type.

Mother dies. The agent configures itself.

On cells, the only thing mother ever produced was a config — she reasoned a team from onboarding, then seeded template files into a freshly-birthed VM. With no VM to provision, the agent can author that config itself. This is your own law made literal: the first-run end state must be agent-authored.

Deleted

zero-mother, the doorbell → wa-bridge → zero-mother chain, the birth skill, publish-template.mjs, and the whole Mac-side birth orchestration. Gone.

The first-run sequence

Cold-start = live status, not a placeholder

No invented deterministic fill. /home shows the advisor's real progress: the first-run skill writes a status to Convex at each checkpoint as it genuinely completes, and the page — subscribed via Convex's reactive query — updates live. The bridge is the agent narrating itself.

Three mechanisms, matched to the job.

Flue gives two native primitives — async dispatch between deployed agents, and synchronous in-process subagents — plus the obvious third: expose a peer as a tool for a sync RPC. Each maps to a real interaction in the funnel.

This matches your card-authorship split exactly: the advisor reacts synchronously to the user, then dispatches the market to author the deep briefing that lands as a card. The "cells talk to cells" mesh becomes native, with no transport to maintain.

Same three births. New bodies.

The product model is unchanged — three births (advisor, market, home agent); the user is created, not born. What changes is the body each runs in.

Specialists (water-rights, flip-check) are no longer agents at all — they're subagents of the market, spawned per task.

Zero isn't a chatbot — it's a standing relationship.

Every household's advisor is named Zero. It's born, then it lives: it remembers, it dreams, and it's reachable on the channels that matter. All four ride the substrate we just defined — memory is Workspace files, dreaming is a Durable Object alarm, the two hats are channels into named sessions. Built on the self-config vertical, in this order.

Memory

Zero's Workspace holds a memory/ store of agent-authored markdown beside IDENTITY.md — what it has learned about you, your search, your constraints. It recalls the relevant files at the top of each turn and writes new ones as it goes. Durable (DO-SQLite + R2); session transcripts are kept automatically. This is the same Workspace the first-run pass already writes to — memory is just more of it.

Yearnings — shared, not per-advisor

Every Zero ships with the same set of yearnings — the standing questions it wants answered about its user: what "a home that takes care of you" means to them, their real all-in (cost-to-zero) budget, their dealbreakers, what they'd trade off, how ready they are, how they want to be advised. The questions are universal — part of Zero's identity. The answers are per-user, and accumulate in memory. Yearnings reweight what Zero studies and asks next.

Shared to start. We ship one fixed set so every Zero behaves consistently; as Zero learns a household over time, the set can grow user-specific standing questions, but the universal core stays. Start uniform, personalize later — not the other way around.

Dreaming

A nightly Durable Object alarm wakes Zero with no user present to run a dream skill: fold the day's sessions into durable memory, merge and prune, revisit yearnings, prep tomorrow's brief. This is the cells "nightly dream," now native to the runtime — no pulse, no claude -p, no Mac cron.

Two hats, on the right channels

Settled spine, named unknowns.

One vertical, end to end.

Prove the model on the cheapest agent that exercises the whole pattern: onboarding answers → a self-configuring advisor you can chat with. Market, home agent, scraping, and the Turso vector brain each become their own later spec — but they all inherit this mold.

Next step: an implementation plan for Slice 1.