A.C.R.E. | GreenhouseAgent

Inspiration

Water stress is not abstract anymore. In places like Arizona, drought restrictions and unpredictable water access can hit growers hard and hurt yield fast. At the same time, a lot of so-called smart plant tools are basically just timers with nicer branding. We wanted to build something that actually reacts to conditions instead of blindly following a schedule.

That became A.C.R.E., our AI-based Climate Regulation Engine. The goal was to make a low-cost greenhouse control system that could read live conditions, pull in outside weather context, and make decisions that were both useful and explainable.

What it does

A.C.R.E. is an AI greenhouse monitoring and control system.

It reads live greenhouse data like temperature, humidity, and light, then combines that with outside weather context so it can reason about what is happening now and what is likely to happen next. From one dashboard, a grower can monitor conditions remotely, switch between manual and automatic control, review logs, and get recommendations like opening vents, closing shade, or delaying watering if rain is likely.

The system supports two intelligence modes. One uses OpenAI for higher-level reasoning and explanations. The other uses our custom local Random Forest model for fast, cheap offline recommendations. We also log sensor readings and actions through Supabase so the system stays inspectable instead of acting like a black box.

How we built it

We built A.C.R.E. as a full loop across hardware, backend, models, and interface.

On the hardware side, we used an Arduino with a DHT11 sensor for temperature and humidity, a photoresistor for light, and servo motors to represent greenhouse actuation. We built a serial relay so Arduino sensor data could flow into a FastAPI backend in real time.

On the software side, the FastAPI server manages live greenhouse state, actuator commands, recommendation routing, and weather context. We pull forecast data through an API so the system does not make decisions based only on indoor readings. The backend can then route the current greenhouse state into either our OpenAI-based reasoning path or our local Random Forest model.

Finally, we built a web dashboard for live readings, weather, recommendations, actuator state, mode switching, and cloud logging through Supabase.

Challenges we ran into

The biggest limitation was hardware. We did not have a water pump or soil moisture sensor, so watering could only be recommended rather than fully automated in a closed loop.

Hardware integration was also harder than expected. Getting stable readings, managing wires, and keeping the servo loop working consistently took multiple iterations. On the software side, moving data cleanly from Arduino to FastAPI and then into the recommendation flow was tricky without dropped messages or parsing issues.

We also spent a lot of time cleaning messy greenhouse data so the Random Forest model could actually be useful as a local baseline.

Accomplishments that we're proud of

We are proud that this became a real end-to-end system instead of just a model demo.

We trained and integrated our own Random Forest model as a local alternative, added an OpenAI path for stronger planning and explanations, built cloud logging through Supabase, and connected everything through a working dashboard that supports remote monitoring and control.

We are also proud that it stayed low-cost while still feeling agentic. The system can observe, reason, recommend, and act inside safety bounds instead of just displaying charts.

What we learned

We learned how hard it is to make hardware, backend systems, cloud logging, and model outputs all feel like one coherent product.

We learned a lot about cleaning real-world data for machine learning, designing a FastAPI backend that can handle continuous updates, and building an interface that makes AI decisions visible rather than hidden. We also learned that reliability matters more than cleverness when your system touches physical controls.

What's next for A.C.R.E.

Next, we want to make A.C.R.E. a true closed-loop greenhouse controller by adding a water pump, soil moisture sensing, and a richer sensor suite like better light and temperature probes.

We also want a stronger fully local mode so growers can run the system without depending on cloud inference. Beyond that, we want to support multiple greenhouse zones, better forecasting, and stronger safety-bounded automation for real deployment.

Built With

• arduino
• c++
• css
• fastapi
• html
• javascript
• open-meteo
• openai
• python
• scikit-learn
• supabase