Where it lives now

The original version was intendeded to run entirely on one Raspberry Pi however, hardware constraints lead to the design decision of running the application as a distributed system comprised of containerised services running on a K3 cluster. Roomy still perceives through a Pi at the edge, but the thinking has moved off it. Today the whole thing runs as a handful of small, single-purpose services on a multi-node K3s cluster.

The division of labour is deliberate. The sensor board lives on an arm64 Pi at the edge (it has the hardware; it does nothing clever). The poet — a local LLM served by Ollama — runs on a beefier node where inference is comfortable. Redis sits in the middle as the memory of the whole system, and a Mosquitto broker carries the messages between nodes. Nothing holds state locally; a pod can die and come back and Roomy doesn’t lose its train of thought, because the train of thought was never in the pod.

%%{init: {'flowchart': {'useMaxWidth': false, 'nodeSpacing': 60, 'rankSpacing': 90, 'padding': 16}, 'themeVariables': {'fontSize': '50px'}}}%%
flowchart LR
    A["Enviro pHAT<br/>(edge Pi)"] -->|MQTT| B["subscriber"]
    B --> C[("Redis<br/>event store")]
    W["Met Office<br/>(outdoor weather)"] --> C
    C --> D["Roomy<br/>(Ollama poet)"]
    D -->|roomy:poems| E["facebook_poster"]
    E --> F["Facebook Page"]
    F -->|comments| G["facebook_responder"]
    G --> D
    C --> H["dashboard<br/>rollups + charts"]

The agent loop

Roomy runs a perceive–interpret–express cycle, and “the loop” is spread across the cluster , enabling high availability. A publisher on the edge Pi reads the board and pushes each reading onto MQTT; a subscriber catches those messages and appends them to a Redis stream — an append-only log that becomes Roomy’s memory of the room over time. The poet reads from that log, not from the sensor directly, which is what lets it reason about trends (“cooler than yesterday”) and not just the instant.

A dedicated facebook page acts as the chat interface where Roomy autonomously posts composed poems on a timer based on current sensor readings. Questions can arrive on an MQTT topic, and comments left on the Facebook Page get pulled back in — so Roomy is genuinely a multi-turn agent, answering in verse.

The one design decision that still matters most is the interpret step. Handing raw floats to a language model produces flat, listy verse. Translating them into qualitative language first — “dim, warm light; air pressure falling” — gives the model imagery to work with and keeps the poem grounded in what actually changed - the model is *never shown a number at all.

How it works

def read_room(sensors) -> dict:
    """Pseudo code"""
    # readings = sensors.get_all()
    # dict readings
    # return readings

TEMP_BANDS  = ((5, "freezing"), (14, "cold"), (19, "cool"), (24, "mild"), (28, "warm"))
LIGHT_BANDS = ((5, "dark"), (60, "dim"), (300, "soft"), (800, "bright"))

def band(value, bands, default):
    # determine which band the reading belongs to 
    # return linguisting label if it falls in defined buckets else return defaul linguisting label
    

def interpret(reading):
    return {
        "temperature": band(reading["temperature_c"], TEMP_BANDS, "hot"),
        "light":       band(reading["light_lux"],     LIGHT_BANDS, "brilliant"),
        # ...pressure, motion, tint the same way
    }

SKILLS = [
    "read_current_room",   # the room now, sense by sense, in mood words
    "recall_trends",       # how it's been trending lately (from the rollups)
    "interpret_conditions",# the current scene in plain mood words
    "read_outdoor_weather",# the weather outside, to contrast with indoors
    "publish_poem",        # release a finished poem (ends the turn)
]

What Roomy writes

A few sample outputs:

Heat rises, a bruised plum stain. Light, soft and hesitant, a slow refrain. Air presses, low and unsettled, a breath of stone. Stillness clings, a weighty, quiet lane. The dust sleeps, a muted, golden plea, this room, a holding, simply free. — Roomy 🏠

Dark clings, a bruised heat. The air, a steady weight, complete. Stillness breathes, a heavy sigh, in this shadowed, breathless sky. Heat presses, a silent plea, within this dark, quiet decree. — Roomy 🏠

Soft light clings, a bruised embrace. The air, a slow warmth, a settled space, heavy, insistent, a humid plea. Stillness breathes, a deep decree, in this shadowed, quiet keep. Heat rises, a phantom sleep, waiting in the dark’s slow weep. — Roomy 🏠

Reflections

• Human readable labels is key. Assigning human readable labels to the readings rather using raw readings works best
• Model Size A model of moderate size is able to produce promising output.
• Put the memory outside the process. Moving from one script to a cluster taught me the same lesson three times: keep the state in Redis and MQTT, keep the pods stateless, and every failure becomes a shrug rather than a crisis. The poet forgetting is fine; the log forgetting is not.
• Multi-turn interaction What makes Roomy feel alive is not any single poem but the fact that continously senses the room and waits to interact with users people can answer.
• Data Privacy:User data is discared rather than stored and consideration is given to data privacy through a working data privacy policy

Next steps

• ** Drive user engagement **: Track user engagement
• ** Poetry Quality **: device a metric for poetry quality and track the metric

Hardware / Setup

flowchart TB
    A("Control Plane (Mini PC)") --> B("Raspberry Pi 4B (Tainted Edge)")
    A --> C("Raspberry Pi 4B (Tainted Edge)")
    A --> E("Musashi (GPU node)")

• Control Plane: The control plane is a mini pc running linux. This routes traffic to all other nodes. [Done]
• Edge Nodes: The raspberry pi nodes are edge nodes running raspbian [Done]
• Msuashi: A GPU node for running LLMs and training models 95% Complete

Core platform services

• Container Registry: A MinIO deployment acting both as storage and a container registry
• Monitoring: A Grafana deployment for monitoring nodes
• GitOps: ArgoCD for streamlining deployment
• Git Repository: Forejo for versioning code and other artefact

Data Science services

• Ollama: A deployment that exposes LLMs downloadable from ollama via a web service
• Qdrant: A vector database for text analytics. This offers both storage and a UI for exploring the stored data.
• Langflow: A service for creating AI workflows via visual interface
• Prefect: Enables the building of data pipelines
• MQTT: For streaming live data from edge nodes (raspberry pi 4B)

Incubation workflow

flowchart LR
    A("An Itch/A need") --> B[["Experimentation/Ideation"]]
    B --> C("Insight / Outcome")
    C --> D{"Repetitive & Generic"}
    D--> E("Yes")
    D--> F("No")
    E--> G("Deploy")

It starts with an itch, a desire to understand which then leads to playful experimentation that generates anecdotal isights that enable me to decide whether or not I should deploy the process as an app.

Lessons learned

• Commerical Generative models like Opus (Claude) and Gemini (3.1) a force multiplier for MLOps productivity
• A homelab cluster can be a cost effective sandox for ideation
• K3, a lightweight kubernetes is quite effective for deploying services - on average less than an hour to deploy a service.

Next steps

• Setup the GPUs on Musashi as a resource in the K3 cluster