Cardona CT Lab AI Tooling · Design & Accessibility
Projects Cultivation Log

Cardona CT Lab / Research Initiative

PlantForge

AI-powered plant care built on Friction Inversion.

Living Whitepaper Research Project Updated Continuously
Current version v0.2.0-dev Research Phase

Research Snapshot / v0.2.0-dev

What are we trying to learn right now?

Current Hypothesis

AI can reduce the cognitive load of plant care more effectively through prediction than through monitoring.

Active

Current Focus

  • Designing PlantOS architecture
  • Designing the PlantOS touch interface in Figma
  • Selecting a long-term hardware platform
  • Evaluating waterproof moisture sensors
  • Defining the Friction Inversion framework

Active Questions

  • How often should plants actually be sampled?
  • Should recommendations be rule-based, AI-driven, or hybrid?
  • Can watering be predicted without explicit thresholds?
  • Which signals provide the greatest predictive value?

Success Criteria

  • Recommendations feel trustworthy.
  • Raw sensor data rarely needs inspection.
  • Notifications are actionable.
  • Watering decisions become nearly effortless.

01 / Vision

Plant care should not depend on perfect memory.

Plant care today is reactive. People are asked to monitor soil moisture, weather, watering schedules, fertilizer timing, and visible signs of stress, then combine those signals into a correct decision.

PlantForge explores an AI-first approach that predicts needs before plants become stressed. The goal is not a denser dashboard. It is a quieter relationship with plant care, where the system converts context into a small number of timely, trustworthy actions.

02 / Friction Inversion

Move the burden from memory into the system.

PlantForge treats plant care as an experience-design problem. Instead of adding reminders to a workflow that already demands too much interpretation, it asks what the software can remove.

Default question

How can users remember to water plants?

Inverted question

How can software eliminate the need to remember?

PlantForge continuously reduces cognitive load through prediction, context, and recommendation. Monitoring is an input to the system, not a responsibility passed back to the user.

Observe

Collect a durable signal from soil and local conditions without asking the person to inspect it.

Interpret

Read the signal against plant identity, environment, and previous care rather than a fixed threshold.

Predict

Estimate the likely need before stress becomes a visible event.

Recommend

Offer one timely action, with enough evidence to earn trust.

Learn

Use the outcome and any human override to improve the next recommendation.

Friction Inversion cycleLive model

03 / Core Principles

Quiet intelligence over constant attention.

01

Predict instead of react.

Surface needs early enough that stress never becomes the interface.

02

Explain instead of expose data.

Translate readings into reasoning people can understand and trust.

03

Context over metrics.

Interpret moisture alongside weather, species, container, light, and history.

04

Reduce decisions.

Offer the smallest useful action rather than another dashboard to inspect.

05

Quiet intelligence.

Remain present in the system without demanding daily attention.

06

Every notification eliminates work.

If a message does not clarify the next action, it should not be sent.

04 / Architecture

Signals become context, then action.

The architecture separates sensing, local coordination, intelligence, and experience. Hardware can evolve without changing the product promise.

Architecture placeholder. Future versions will expose data contracts, transport protocols, local inference boundaries, and service responsibilities.

05 / System Components

A platform, not a sensor.

OPERATING LAYER

PlantOS Core

Coordinates plant identity, sensor history, care events, recommendation state, and system rules.

EDGE LAYER

Plant Nodes Planned

Collect environmental signals near each plant and transmit durable, calibrated observations.

LOCAL LAYER

Plant Hub Research

Provides local orchestration, device management, resilience, camera support, and future inference.

VISION LAYER

Plant Vision Future

Uses image history to identify growth, discoloration, wilting, pests, and visible stress patterns.

INTELLIGENCE LAYER

Plant AI Research

Combines rules, models, environmental context, and conversational explanation into recommendations.

SERVICE LAYER

Plant Cloud Future

Supports remote access, model updates, shared plant knowledge, backup, and public API capabilities.

06 / Prototype Build

Build the smallest system that can test the hypothesis.

The v0.1 build is an observation rig, not an automated watering product. Its job is to collect a trustworthy moisture signal, pair it with environmental context, and create enough history to test whether prediction can remove decisions.

Why an ADC is required

The selected moisture probe produces an analog signal. Raspberry Pi does not provide analog inputs, so the ADS1115 converts that signal into a stable digital reading over I2C.

Prototype boundary

Sense and observe first. Pumps, relays, and unattended watering remain outside v0.1 until the recommendations prove trustworthy.

01
Raspberry Pi 5, 8GBCore / Quantity 1$200.00 at Adafruit

Runs the Plant Hub, local data services, dashboard, and future inference experiments.

View part ↗
02
Official 27W USB-C power supplyCore / Quantity 1$14.04 at Adafruit

Provides the stable 5V/5A power profile specified for Raspberry Pi 5.

View part ↗
03
Official Raspberry Pi 5 Active CoolerCore / Quantity 1$13.50 at Adafruit

Keeps sustained local services and future inference workloads thermally stable.

View part ↗
04
Official Raspberry Pi 5 Case + FanProtection / Quantity 1$12.00 at Adafruit

Protects the hub board and provides temperature-controlled airflow. Install it in a dry, elevated location away from irrigation.

View part ↗
05
Raspberry Pi microSD card, 64GBCore / Quantity 1$29.95 at PiShop.us

Holds the operating system, prototype services, logs, and early observation history.

View part ↗
06
DFRobot SEN0308 moisture sensorCore / Quantity 1$14.90 at DFRobot

Provides an IP65, corrosion-resistant capacitive moisture signal through a 1.5 meter cable.

View part ↗
07
Adafruit ADS1115 16-bit ADCCore / Quantity 1$14.95 at Adafruit

Converts the sensor's analog output into a high-resolution I2C reading the Pi can use.

View part ↗
08
Jumper wires and breadboardCore / Quantity 1 setPrice varies at Adafruit

Supports a reversible bench build before the wiring and enclosure are made permanent.

Browse parts ↗
09
Adafruit BME280Optional context / Quantity 1$14.95 at Adafruit

Adds temperature, humidity, and pressure so moisture changes can be interpreted in context.

View part ↗

Prices checked July 25, 2026. Purchase links use Adafruit when the exact part is available there. Other links go to the manufacturer. These are not affiliate links. Availability and pricing can change.

Build sequence

  1. Install Raspberry Pi OS, enable I2C, and update the system.
  2. Mount the Active Cooler before placing the Pi in its dry, ventilated enclosure.
  3. Connect the ADS1115 to the Pi, then connect the moisture sensor to channel A0.
  4. Confirm raw readings in air and representative soil before collecting care data.
  5. Calibrate against the same soil, container, insertion depth, and packing used in the study.
  6. Log observations before adding recommendations, alerts, or automation.

v0.1 wiring map

Pi 3.3VADS1115 VIN
Pi GNDADS1115 GND
Pi GPIO2 / SDAADS1115 SDA
Pi GPIO3 / SCLADS1115 SCL
Sensor signalADS1115 A0
Sensor VCC / GND3.3V / common GND

Electrical constraint: Run the prototype sensing circuit at 3.3V. Keep the Pi, ADC, connections, and power supply dry. Only the rated probe and cable belong near soil or water.

Ideal Research Platform

The Jason-level build.

This is the durable PlantForge system I would build for long-term research. It replaces fragile analog wiring with industrial sensing, adds repeatable vision, and reserves enough local compute for the intelligence layer to mature.

Planning range $1,100–$1,350

Plant Hub

H1
Raspberry Pi 5, 16GBHub / Quantity 1$350.00 at Adafruit

Provides headroom for PlantOS, containers, databases, dashboards, image processing, and development services.

View part ↗
H2
Raspberry Pi AI HAT+ 2AI expansion / Quantity 1$200.00 at Adafruit

Adds 40 TOPS and 8GB of dedicated memory for future local vision, VLM, and constrained language-model experiments.

View part ↗
H3
Official Active CoolerThermal / Quantity 1$13.50 at Adafruit

Keeps the Pi thermally stable beneath the AI HAT during sustained local workloads.

View part ↗
H4
Official Raspberry Pi 5 Case + FanProtection / Quantity 1$12.00 at Adafruit

Protects the hub in a dry, elevated location. Its removable top supports future HAT clearance with the correct spacers.

View part ↗
H5
Official 27W USB-C power supplyPower / Quantity 1$14.04 at Adafruit

Provides the stable power budget required by the Pi, AI accelerator, camera, and USB devices.

View part ↗
H6
Samsung T7 Shield, 1TBStorage / Quantity 1$287.99 at Samsung

Stores PlantOS, sensor history, images, models, and backups over USB 3 while the AI HAT occupies PCIe.

View part ↗
H7
64GB Raspberry Pi microSD cardRecovery / Quantity 1$29.95 at PiShop.us

Provides bootable recovery media while the external SSD serves as primary working storage.

View part ↗

Durable Sensing

S1
DFRobot SEN0601 RS485 soil sensorPrimary signal / Quantity 1+$39.00 each at DFRobot

Measures moisture, soil temperature, and electrical conductivity in an IP68 body designed for long-term burial.

View part ↗
S2
Waveshare isolated USB to RS485 converterInterface / Quantity 1$17.99 at Waveshare

Connects the MODBUS sensor bus to the Plant Hub with galvanic isolation and line protection.

View part ↗
S3
Regulated 12V supply and fused field boxInfrastructure / Quantity 1Price varies by final enclosure

Powers the field bus and keeps fusing, terminals, strain relief, and cable transitions protected and serviceable.

Browse power ↗

Environmental Context and Vision

C1
Sensirion SCD-41Environment / Quantity 1$49.95 at Adafruit

Adds CO₂, temperature, and humidity context for understanding indoor environmental change.

View part ↗
C2
VEML7700 ambient light sensorLight / Quantity 1$4.95 at Adafruit

Creates a dependable ambient-light history before the research justifies a dedicated PAR sensor.

View part ↗
C3
Raspberry Pi Camera Module 3 WideVision / Quantity 1$38.50 at Adafruit

Provides autofocus, a wide field of view, and native camera-stack integration for repeatable plant imaging.

View part ↗
C4
Rigid camera mount, diffuse high-CRI light, and color targetImaging control / Quantity 1 setPrice varies by final rig

Controls framing and illumination so image differences are more likely to represent the plant rather than the room.

Browse mounts ↗
PHASE 01 Start here

Bare-minimum durable observation system

Start with one professional signal path and the final hub platform. This avoids buying an interim computer or disposable analog sensing hardware.

Phase estimate: $520–$570Cumulative: $520–$570
Exit criterion

PlantForge records stable moisture, soil temperature, and conductivity readings for at least two weeks and preserves them through restarts without manual intervention.

PHASE 02

Reliable storage and environmental context

Move the working system off microSD and add enough context to distinguish plant behavior from room behavior.

Phase estimate: $345–$365Cumulative: $865–$935
Exit criterion

The system correlates soil changes with light and room conditions, retains a useful observation history, and produces dependable daily summaries.

PHASE 03

Repeatable Plant Vision

Add images only after the signal pipeline is trustworthy. Controlled framing and lighting matter more than collecting a large number of inconsistent photos.

Phase estimate: $120–$195Cumulative: $985–$1,130
Exit criterion

PlantForge captures consistently framed and color-normalized images that can reveal growth or visible stress without room-lighting artifacts.

PHASE 04

Local intelligence

The accelerator is intentionally late. It becomes useful when PlantForge has real observations, images, and defined inference tasks.

Phase estimate: $200Cumulative: $1,185–$1,330
Exit criterion

A local model performs one defined PlantForge task more privately, quickly, or economically than the existing rules or cloud workflow.

PHASE 05

Scale to multiple plants

Expand only after one plant produces useful evidence. Additional sensors should improve the model, not multiply maintenance.

Phase estimate: $50–$120 per plantCumulative: depends on plant count
Exit criterion

New plants can be commissioned predictably without changing the hub architecture or degrading the quality of existing observations.

Prices checked July 25, 2026. This is the target research architecture, not the minimum viable purchase. Purchase links use Adafruit when the exact part is available there and otherwise go to the manufacturer. These are non-affiliate references. Confirm regional compatibility, current specifications, availability, and price before ordering.

07 / PlantOS Code

Code now. Connect hardware later.

PlantOS begins as a simulation-first software core. Virtual sensors let us define trustworthy data, recommendation behavior, and experience boundaries before the first probe arrives.

PrototypeTypeScript core + Python baseline
InputDeterministic virtual simulator
OutputRuntime-validated observations
SafetyNo watering actuation

The hardware seam

// Virtual today. Physical later.
const scenario = {
  ...DEFAULT_SIMULATOR_SCENARIO,
  seed: 42,
  durationHours: 72
};

const run = simulate(scenario);

for (const observation of run.observations) {
  process.stdout.write(`${JSON.stringify(observation)}\n`);
}

Research guardrail: PlantOS may recommend that a person review watering. It does not issue an actuator command. Automation comes only after the observations and policy earn trust.

Current source map

  • plantos/
  •   packages/contracts/
  •   packages/simulator/
  •   tests/contracts.test.ts
  •   tests/simulator.test.ts
  •   plantos/ Python baseline

Run without parts

cd plantos
npm.cmd install
npm.cmd run simulate -- --hours 72 --seed 42
npm.cmd run typecheck
npm.cmd test

Language direction: TypeScript is the default for new services, APIs, shared contracts, dashboard logic, and automation. Python remains available for hardware integration, scientific tooling, and model experiments when it provides a clear advantage.

07A / Interface Design

Design the calm before the hardware arrives.

PlantOS Touch UI v0.1 turns the coded display preview into a reusable Figma component system. The purpose is to validate the experience, touch targets, and decision hierarchy while the system still runs on deterministic research data.

01

Five truthful states

Healthy, review watering, stale signal, no reading, and conflicting signal must match the PlantOS fixtures exactly.

02

Decision first

The recommended next step appears before raw measurements, with evidence close enough to inspect.

03

Component-ready

Status chips, recommendation cards, metrics, and the decision trail become reusable variants rather than one-off screens.

04

Accessible touch

Essential controls use at least 44 by 44 pixel targets. Color never carries status alone.

Design filePlantOS Touch UI v0.1
Device frame7-inch landscape touch display
Source dataVersioned PlantOS fixtures
SafetyNo automatic watering control
01Brief
02Information architecture
03Tokens and components
04Build plan
05Implementation
06Visual and accessibility review
07Publish and learn

The Friction Inversion Design Loop keeps the product brief, component choices, rendered interface, and review evidence in agreement. It is the working method for material PlantOS interface changes.

Open touch-screen preview

07B / Figma Handoff

One vocabulary from design to PlantOS.

This space defines the Figma file structure and import boundary for PlantOS Touch UI v0.1. Variables can enter Figma through the existing token-import pattern. Components and editable screens remain a deliberate design-library build.

FilePlantOS Touch UI v0.1
PagesFoundations, Components, Screens, Flows
SourcePlantOS contracts and fixtures
ImportVariables first, components second
01

Screen naming

Use Touch / Healthy Signal and Touch / Review Watering. Name the experience, not the visual treatment.

02

Component naming

Use singular components such as Status Chip, Recommendation Card, and Evidence Row.

03

Contract-native variants

Use values such as state=review_watering and signal=stale so Figma, fixtures, and code agree.

04

Semantic layers

Use roles such as header, label, metric-value, and evidence-list, never visual descriptions.

01Create the Figma file
02Import PlantOS variables
03Build canonical components
04Bind state variants
05Link fixture names
06Review accessible states
07Map to implementation

Recommended variable namespaces: color/base, color/surface, color/text, color/status, space, radius, and size/touch/min. The minimum touch-size value is 44.

Open Figma handoff spec

07C / Pre-hardware Sprint

Prove the product before the parts arrive.

The first PlantForge sprint builds software evidence, design decisions, and installation discipline before sensor noise can obscure the work.

01 / Complete

Touch UI

Figma-ready specification and state-aware preview.

02 / Complete

Simulation

Weather, calibration, and fault context in deterministic runs.

03 / Complete

Dashboard

Profile, history, decision trail, and human correction context.

04 / Complete

Data model

Plant profiles, care events, and overrides use validated contracts.

05 / Complete

Calibration

Commissioning turns installation into bounded evidence.

06 / Complete

Evaluation

Five safety states pass before policy changes can advance.

07 / Complete

Cultivation Log

Research decisions and lessons stay visible as the system evolves.

08 / Complete

Physical install

Placement, recovery, and setup are designed before first use.

07D / Display Emulator

Rehearse the decision before it reaches a person.

This interactive prototype turns deterministic PlantOS scenarios into the calm, explainable display we are building toward. It is a research model, not a connected plant dashboard.

Open touch-screen preview

Interactive prototype

PlantOS care display

Simulation mode
Office plant / plant-001

Monstera deliciosa

Signal healthy
PlantOS recommendation No action right now

Moisture is stable and the sensor is current. PlantOS will keep observing without adding a task.

Soil moisture51.4%
Signal healthHealthy
Last readingJust now
Why this recommendation 3 recorded events

    Healthy signal selected. No action right now.

    Prototype states and decision trails are generated from versioned PlantOS contracts, policy fixtures, and append-only local audit events. Add ?plantos-api=local during local development to load the same status and audit shape from the read-only API.

    08 / Friction Inversion Cycle

    PlantForge is the first live methodology test.

    The FI Cycle tracks more than what PlantForge removes. It records where the work moves, who carries it, which signals reveal new pressure, and when the system must be rebalanced.

    Correct result

    A trustworthy care decision before stress.

    The user receives a timely recommendation without monitoring raw readings or reconstructing environmental context.

    Determinants

    The problem is interpretation, not memory.

    • Signals are fragmented.
    • Care thresholds depend on context.
    • Feedback arrives after stress.
    • Recommendations must earn trust.
    Inversion

    Move observation into PlantOS.

    PlantOS collects and interprets conditions continuously. The person reviews a recommendation only when the evidence supports attention.

    Guardrails

    Recommendation before actuation.

    • No automatic watering in the research phase.
    • Reasons remain visible.
    • Invalid readings fail closed.
    • Human overrides remain part of the evidence.
    Leading indicators

    Watch pressure before failure.

    • Sensor disagreement
    • Recommendation overrides
    • Unnecessary notifications
    • Repeated manual corrections
    • Time from recommendation to action
    Friction relocation

    Memory becomes system maintenance.

    The burden moves from daily user attention into calibration, model review, sensor health, and explanation quality. That relocation is acceptable only while it remains visible and serviceable.

    What this teaches us now

    Prediction is useful only when it reduces decisions without hiding uncertainty. Simulation removes the dependency on physical parts, but it does not remove the future need for calibration. Quiet intelligence must measure notification burden as carefully as plant outcomes.

    09 / Research Timeline

    Evidence before automation.

    July 2026 / Foundation

    Initial research phase

    • Defined PlantForge and its relationship to Friction Inversion.
    • Selected Raspberry Pi as the initial platform direction.
    • Began premium hardware and waterproof capacitive sensor research.
    • Established the Living Whitepaper as the canonical project record.
    Next / Observation

    Prototype the signal layer

    Compare wireless node approaches, calibrate sensors, establish sampling behavior, and observe how environmental readings change across real care events.

    Future / Intelligence

    Move from readings to prediction

    Evaluate predictive watering, AI recommendations, plant vision, and the trust model required before any care action becomes automated.

    10 / Architecture Decision Records

    Decisions remain visible and revisable.

    ADR-001Use Raspberry Pi 5 as the central hubAccepted

    Reasoning: Raspberry Pi 5 leaves room for local services, Home Assistant integration, dashboards, cameras, and future local inference without prematurely constraining the research.

    ADR-002Use capacitive moisture sensorsAccepted

    Reasoning: Capacitive sensing avoids exposed resistive probes and offers a more credible path toward long-term stability. Waterproof construction and calibration quality remain active selection criteria.

    ADR-003Use a hybrid recommendation modelProposed

    Reasoning: Deterministic rules can protect safety boundaries while AI interprets context and explains why an action is recommended. This requires validation before acceptance.

    ADR-004Prefer TypeScript for application and service codeProposed

    Reasoning: TypeScript provides shared contracts across services, APIs, automation, and the dashboard. Python remains appropriate at hardware, scientific, and model-experiment boundaries. Versioned data contracts keep those boundaries explicit.

    11 / Roadmap

    From first principles to quiet automation.

    01ResearchCurrent
    02PrototypeNext
    03SensorsPlanned
    04DashboardPlanned
    05AIFuture
    06PredictionFuture
    07AutomationFuture
    08VisionFuture

    12 / The Cultivation Log

    The engineering notebook inside the whitepaper.

    The Living Whitepaper explains what PlantForge is. The Cultivation Log documents how PlantForge became what it is.

    July 27, 2026

    Pre-hardware product sprint closes the gap between idea and evidence

    v0.2.0-dev

    Summary

    PlantOS now includes a Figma-ready touch UI specification, weather and calibration-aware simulation, validated plant-profile and care-history contracts, a dashboard history surface, and a five-state evaluation harness. The work is intentionally useful before a sensor is purchased.

    Decisions and Lessons

    • Hardware should enter a defined system, not define it.
    • Human care history and overrides are first-class product evidence.
    • Calibration is a commissioning process, not a one-time threshold.
    • Every safety state needs a visible experience and an automated check.

    Next Steps

    • Build PlantOS Touch UI v0.1 in Figma from the shared specification.
    • Choose the first plant and complete its profile before installation.
    • Commission the first node against the calibration plan.
    • Compare real observations with the simulation baseline.
    July 26, 2026

    TypeScript simulator establishes a traceable baseline

    v0.2.0-dev

    Summary

    PlantOS now has strict TypeScript contracts, deterministic baseline and fault scenarios, an explainable safety-first policy, append-only local decision trails, and a local read-only API. The Living Whitepaper display emulator loads the generated fixture and shows the evidence path that produced each recommendation.

    Decisions and Lessons

    • Keep the Python simulator as a research baseline.
    • Use TypeScript for shared contracts and new application code.
    • Model healthy, watering-review, stale, missing-data, and conflicting-signal states before dashboard implementation.
    • Never permit degraded evidence to become a watering recommendation.
    • Record the evidence path in append-only order before exposing the recommendation.

    Next Steps

    • Build a dedicated research dashboard from the same API.
    • Add accessibility evidence and narrow-view testing.
    • Compare fixture behavior with the first physical sensor node.
    • Prepare the v0.2.0 release record.
    July 26, 2026

    The methodology becomes measurable

    v0.1.1

    Summary

    PlantOS gained a simulation-first code scaffold. The FI Cycle was applied to define the correct result, determinants, guardrails, leading indicators, and expected friction relocation.

    Decisions and Lessons

    • Develop the software before hardware arrives.
    • Recommend before actuating.
    • Treat overrides and notification burden as evidence.
    • Keep relocated maintenance work visible.

    Next Steps

    • Define a persistent observation store.
    • Add sensor-health states.
    • Record simulated recommendation outcomes in the Friction Ledger.
    July 25, 2026

    Project foundation

    v0.1.0

    Summary

    PlantForge officially started. The vision, product philosophy, architecture direction, and Living Whitepaper structure were established.

    Decisions and Lessons

    • Use Friction Inversion as the core philosophy.
    • Begin with Raspberry Pi.
    • The project is about cognitive load, not soil moisture.

    Next Steps

    • Research premium moisture sensors.
    • Prototype the first hardware stack.
    • Define the initial data model.

    Future Hooks

    Designed to become a live system record.

    Interactive architecture diagrams
    Live hardware status
    Plant dashboard screenshots
    Sensor calibration charts
    Growth analytics
    Time-lapse gallery
    AI conversation examples
    Whitepaper PDF export
    Public API documentation