LLM Agents: When a Language Model Takes Over the Farm

From reading the data to running the farm

Modern indoor farms drown in numbers. A single growing chamber can carry dozens of sensors sampling many times a second, measuring everything from leaf temperature to the electrical impedance of a stem. The industry has a phrase for the result, data rich and information poor. There is far more signal than any agronomist can watch, and the relationships between those signals are tangled, nonlinear, and constantly shifting as the plant responds to its environment.

Language models are good at exactly this kind of messy synthesis, spotting that a change in stem impedance lines up with a shift in how the leaves are breathing and a dip in an air quality reading. So the first use is obvious and already common, translating the sensor wall into plain language a specialist or a curious hobbyist can understand. This paper, by Serge Kernbach at a German research firm, treats that as merely the warm up. Its real claim is that the same model can close the loop, taking its own reading of plant physiology and turning it directly into action on the hardware.

That shift, from interpreter to controller, is the whole point. Instead of following a fixed schedule of lights and water, the agent evaluates the living system in front of it and adjusts, the way a skilled grower would, except continuously and without sleep. It is the agricultural cousin of a broader move across science, seen for instance in our coverage of an agentic AI that operates a synchrotron beamline, where a language model reads instrument data and issues the commands to run an experiment. Here the instrument is a crop.

Two agents, one thinking fast and one thinking slow

The clever piece of engineering is how the system avoids overloading a single model with too many jobs at once. Asking one agent to simultaneously perform deep physiological analysis and rapid low level actuation dilutes its attention and degrades both. The solution borrows a familiar idea, splitting the work across two agents that run on different clocks.

The Worker Agent is the hands. It runs on every short control cycle, reads the latest sensor data, and synthesizes the actual command sequence, formatted as a rigid block of structured data that the hardware can execute. It is focused on the here and now, on what the lights and pumps should do in the next window.

The Scout Agent is the eyes and the memory. It runs roughly once a day, sifting through the long history of telemetry to spot systemic anomalies and slow trends the Worker would miss in its narrow window. Crucially, the Scout does not just report. It rewrites the Worker’s instructions, steering the fast agent’s attention toward whatever the long view has flagged as important. About a third of the Worker’s prompt is given over to this guidance from the Scout. One agent thinks fast and acts, the other thinks slow and directs. It is an attention router built out of two language models.

The Scout is a digital botanist studying the crop’s long term behavior, and the Worker is the hand on the switch. The Scout does not merely advise the Worker. It rewrites what the Worker is told to care about.A plain reading of the two agent design

Keeping a hallucinating model on a leash

Handing control of physical hardware to a model that can confidently invent facts is obviously risky, and the paper does not pretend otherwise. Its answer is a three layer safety approach that is worth studying because it generalizes to any agent touching the real world.

First, the model is grounded. Its reasoning is restricted strictly to the real sensor readings in front of it, not its general recollections about plants. Second, its output is constrained to a rigid, predefined schema, so it cannot emit a free form instruction that the hardware might misread, only a valid, checkable command. Third, and most practically, a local script on the edge hardware turns raw sensor data into control tables and feeds those back into the model as a reality check, along with a validator that inspects every incoming command before it reaches a relay. The model proposes, but a deterministic guard decides whether the proposal is even allowed to run.

This layered discipline, grounding the reasoning, constraining the output, and verifying against the hardware, is the difference between a chatbot that might be wrong and a controller that fails safe when it is. It is the same reliability concern that runs through work on whether these models can be trusted as evaluators at all, a theme we explored in whether language models can reliably judge communication.

Telling it what good looks like

An autonomous grower needs a goal. The system was given two, expressed as simple objective functions the agent optimizes toward. One is speed, maximizing how fast fresh shoot biomass accumulates. The other is thrift, maximizing the biomass gained per unit of electrical energy spent.

Those two lines hide a real subtlety the author had to defend against. If you naively tell an agent to maximize biomass per watt, the cleverest move is to turn the lights off entirely, spending zero energy and gaming the ratio. The system prevents this by tying the numerator directly to the biomass sensor, so that if growth stalls the efficiency ratio collapses to zero regardless of the energy saved, forcing the model to keep the crop actually growing. Designing an objective that cannot be trivially cheated is half the battle in any autonomous system, and the paper is candid that it had to iterate on this.

To pursue these goals the agent shifts between modes, described in the paper in language borrowed from optimization. In an exploration mode it behaves like a mutation operator in a genetic algorithm, proposing candidate lighting recipes by riffing on its history. In another it reasons like a reinforcement learner following a mostly greedy strategy, treating the growth rate as a reward. When the crop hits a plateau or a stress signal, it switches to a predictive mode, projecting the plant’s state hours ahead to steady it. Whether the model truly performs these algorithms or merely narrates them in their language is a question we will return to, because it is the paper’s deepest limitation.

What the agent achieved

The results, averaged over five growth cycles per setting, show a clear and sensible set of tradeoffs against a conventional fixed schedule.

Told to grow wheatgrass as fast as possible, the agent extended the daylight period toward continuous light, a known speed breeding trick, and pushed the crop to a harvest ready height of around twenty centimeters in four and a half days, roughly a third faster than the baseline. Told to save energy instead, it exploited the plant’s physiological inertia, using short light pulses and letting the crop coast through relaxation periods, trimming energy by 18 percent for a modest increase in growing time.

The strategy nobody asked for

The most interesting result is the one the author did not design. Left to minimize energy aggressively, the two agents converged on a strategy the paper calls ultra minimum. The Scout, studying the long record, directed the Worker to stop using broad full spectrum light altogether and instead deliver short bursts of blue and red separated by long stretches of darkness.

This is a real and somewhat counterintuitive piece of plant biology. A controlled light deficit triggers the plant to build extra chlorophyll to capture what little light it gets, a compensatory response known as dark induced chlorophyll accumulation. The upshot was startling on the meter, nearly a 68 percent energy reduction against the already frugal energy saving mode, and around 74 percent against the standard baseline. And it was not a pyrrhic saving. The resulting wheatgrass had more chlorophyll, more antioxidant content, less tough fiber, and yielded an estimated twenty to twenty five percent more juice, all while keeping the growth rate roughly steady.

The author draws the right parallel. This resembles how a genetic algorithm stumbles onto solutions its designers never anticipated by exploiting properties of the system they had not thought to use. The agent was not told about dark induced chlorophyll accumulation. It found a control pattern that happened to trigger it, in pursuit of a simple energy goal. That capacity for a language model to discover a useful, unplanned strategy in a living system is the paper’s most provocative claim.

Reading the plant, not just running it

Two further case studies show the same system working as a diagnostician rather than a controller, and they are where the plain language ability earns its keep. In one, the Scout agent studied several weeks of data from a single Dracaena plant and correctly flagged a physiological crisis, a hydraulic breakdown in the stem that had triggered an emergency stomatal closure, distinguishing it cleanly from a mere sensor glitch by cross checking several signals at once. It then produced two explanations of the same event, a technical one for a specialist and a plain one for everyone else, describing how the plant had deployed its biological version of sunglasses to scatter excess light while it locked down its water.

Notably, this diagnostic ability depended on the model being capable enough. When the author compared several models on the anomaly, the mid range and larger ones from the major families identified the correct event, while the smallest models failed outright, and success required extended step by step reasoning rather than a snap answer. A third case study pushed to finer timescales, catching a fleeting reversal of the plant’s internal water flow triggered by a temperature drop of just over one degree, while a smaller drop produced no such response, a neat demonstration that the interesting biology here is full of nonlinear thresholds. The domain being agriculture, this diagnostic thread connects naturally to computer vision work in the field like our look at testing plant segmentation under field occlusion.

The honest limitation, a black box giving orders

The paper is refreshingly clear eyed about what it has not shown, and the central caveat is important enough to sit at the center of any fair reading. The models hallucinate. They occasionally produce incorrect numbers or assert correlations that do not exist, which is exactly why the three layer safety net matters so much.

But the deeper problem is interpretability. When the agent says it is behaving like a reinforcement learner or projecting the plant’s state forward like a predictive controller, there is no way to verify that it actually does any such thing. The optimization it narrates in its rationale may be a genuine internal process, or it may be a plausible story the model tells about decisions it reached some other way. The physiological explanations it offers for anomalies, however convincing, likewise cannot be definitively confirmed. This is the uncomfortable heart of handing control to a language model. It gives orders and it gives reasons, and the reasons sound right, but the link between them is opaque.

This is why the author is careful to frame the system as a copilot rather than an autopilot. The AI dramatically accelerates the handling of data and the running of routine cycles, but a human expert is still needed to validate that the biology checks out. The expert’s job shifts from manually mining data to rapidly supervising an agent, which saves an enormous amount of labor, but it does not disappear. That distinction, between an accelerant and a replacement, is the sober conclusion the results actually support.

The core method, in runnable Python

The block below is a faithful, self contained reference implementation of the closed loop control architecture, including the two agent topology, the rigid command schema, the safeguard validator that gates every command, the two objective functions with the anti gaming fix, and a simulated edge loop driving a mock plant. The language model call is stubbed so the whole thing runs offline. It follows the framework described in the paper.

# Closed-loop LLM control for a vertical farm.
# Worker agent (fast, per micro-cycle) + Scout agent (slow, daily).
# A safeguard validates every JSON command before it reaches the hardware.
import json, random
from dataclasses import dataclass, field

# ----------------------------------------------------------------------
# 1. Rigid command schema and the deterministic safeguard
# ----------------------------------------------------------------------
CHANNELS = ["full_spectrum", "blue_450", "red_660", "irrigation"]
MAX_WINDOW_MIN = 60

def safeguard(cmd):
    """Validate an incoming command. Reject anything off-schema (fail safe)."""
    if not isinstance(cmd, dict): return None
    out = {}
    for ch in CHANNELS:
        v = cmd.get(ch, 0)
        if not isinstance(v, (int, float)) or not (0 <= v <= 1):
            return None                                  # out of range -> reject whole command
        out[ch] = float(v)
    w = cmd.get("window_min", 30)
    if not (10 <= w <= MAX_WINDOW_MIN): return None
    out["window_min"] = int(w)
    return out

# ----------------------------------------------------------------------
# 2. Objective functions (with the anti-gaming fix)
# ----------------------------------------------------------------------
def j_time(delta_biomass, minutes):
    return delta_biomass / max(minutes, 1)             # d(FSB)/dt

def j_energy(delta_biomass, watt_hours):
    # if growth stalls the ratio collapses, so the agent cannot cheat
    # by simply switching the lights off to spend zero energy
    if delta_biomass <= 0.0: return 0.0
    return delta_biomass / max(watt_hours, 1e-6)

# ----------------------------------------------------------------------
# 3. Agents. Replace `call_llm` with a real model client in practice.
# ----------------------------------------------------------------------
def call_llm(prompt):
    """Stub. A real client returns a JSON command string from the prompt."""
    energy_mode = "minimize energy" in prompt
    if energy_mode:                                    # emergent 'ultra minimum' shape
        pulse = random.random() < 0.35
        cmd = {"full_spectrum": 0.0,
               "blue_450": 0.5 if pulse else 0.0,
               "red_660": 0.5 if pulse else 0.0,
               "irrigation": 0.2, "window_min": 60}
    else:                                              # time-optimal: push the light
        cmd = {"full_spectrum": 1.0, "blue_450": 0.5,
               "red_660": 1.0, "irrigation": 0.5, "window_min": 60}
    return json.dumps(cmd)

def scout_agent(history):
    """Slow agent: scan long-term history, return a focusing directive."""
    if len(history) > 3 and sum(h["d_biomass"] for h in history[-3:]) < 0.3:
        return "ANOMALY: biomass plateau, prioritize stabilization"
    return "nominal: continue current objective"

def worker_agent(sensors, objective, scout_note):
    # ~30% of the prompt is the Scout's guidance
    prompt = (f"OBJECTIVE: {objective}\nSCOUT: {scout_note}\n"
              f"SENSORS: {json.dumps(sensors)}\n"
              "Return a JSON actuation command.")
    return safeguard(json.loads(call_llm(prompt)))       # validate before use

# ----------------------------------------------------------------------
# 4. Simulated plant + edge control loop
# ----------------------------------------------------------------------
def step_plant(cmd):
    # toy physiology: growth needs some light; energy is what you spend
    light = cmd["full_spectrum"] * 37.5 + cmd["blue_450"] * 6.25 + cmd["red_660"] * 12.5
    wh = light * cmd["window_min"] / 60.0 / 1000.0
    # dark-induced accumulation: some growth persists even at low light
    d_biomass = 0.2 + 0.6 * min(light / 40.0, 1.0) + random.uniform(-0.05, 0.05)
    return d_biomass, wh

def run(objective, cycles=12):
    history, biomass, energy = [], 0.0, 0.0
    for t in range(cycles):
        note = scout_agent(history) if t % 4 == 0 else "nominal"   # Scout runs slowly
        sensors = {"biomass": round(biomass, 2), "moisture": 0.7}
        cmd = worker_agent(sensors, objective, note)
        if cmd is None:                                 # safeguard rejected: hold safe default
            cmd = {"full_spectrum": 0.5, "blue_450": 0, "red_660": 0.25,
                   "irrigation": 0.3, "window_min": 30}
        db, wh = step_plant(cmd)
        biomass += db; energy += wh
        history.append({"d_biomass": db, "wh": wh})
    return biomass, energy

if __name__ == "__main__":
    for obj in ("maximize growth rate", "minimize energy"):
        b, e = run(obj)
        print(f"{obj:22s} biomass={b:5.2f}  energy={e:.4f} kWh  "
              f"J_energy={j_energy(b, e * 1000):.3f}")
    print("smoke test ok")

Conclusion

The central contribution of this work is a demonstration that a language model can cross the line from describing a biological system to running one. By closing the loop between plant sensors and hardware actuators, the system moves an LLM from the dashboard into the control panel, and it does so with an architecture thoughtful enough to be taken seriously, splitting fast action from slow analysis and wrapping the whole thing in layers of grounding and validation that keep a fallible model from doing damage.

The most memorable result is the emergent one. An agent pursuing a simple energy target discovered, without being told, a control pattern that triggers a real physiological response and slashed power use while improving the crop. That a language model can land on a genuine, useful strategy in a living system, in the same accidental way a genetic algorithm exploits properties its designers never considered, is a striking illustration of what autonomous experimentation might offer. It reframes these agents not just as executors of known recipes but as searchers that can occasionally find something new.

What keeps the paper grounded is its honesty about the catch. The models hallucinate, and more troublingly, there is no way to verify that the agent actually performs the optimization it narrates. The gap between the reasons a model gives and the process it followed is the defining uncertainty of agentic AI in the physical world, and this study neither hides it nor pretends to have solved it. It simply builds the guardrails that make the uncertainty tolerable and keeps a human in the supervisory seat.

The practical limitations are real. This is a single author preprint demonstrating a framework rather than a large controlled trial, the emergent strategy is shown across a handful of growth cycles rather than proven at industrial scale, and the diagnostic anomalies are rare events illustrated rather than statistically validated. The physiological explanations, compelling as they are, remain unconfirmed by design. None of this diminishes the demonstration, but it places it firmly at the proof of concept stage.

Read as a finished product, this is not one. Read as a signpost, which is whether a language model can serve as an autonomous controller and occasional discoverer in a real biological system, it offers a persuasive and carefully qualified yes. For digital agriculture, and for the wider project of letting agents touch the physical world, the combination shown here, genuine autonomy paired with an unflinching account of what cannot yet be verified, is exactly the right way to move the idea forward.