A farm-patrol rover drives itself with zero AI on board. The model we wanted for its voice doesn't fit on its own computer yet.

5 September 2026. Tark2, a real predator-deterrence rover being built for a duck pen in southern Oregon, got an offline autonomous-mission mode, a validated 4B-class language model on a spare GPU, and one small-model install attempt that never made it to loading a single weight. All three numbers below came off real hardware, not a paper.

Tark2's brain is a Jetson Orin Nano Super — a single-board computer about the size of a deck of cards, running the camera, the wildlife-detection software, and the drive electronics for a tracked rover that has to operate for hours with nobody watching it. The question this session answered was simple to ask and easy to get wrong: does making that rover act on its own require a language model at all?

It doesn't. The part that shipped first — the part that has to work with no network connection of any kind, because the whole point is a rover that can be out of range — is a deterministic step sequencer with no model in it whatsoever.

1. What "autonomous" turned out to mean

A mission is an ordered list of relative moves: turn this many degrees, drive this far, repeat. No GPS, no compass — this rover has neither — so every step is relative to wherever the rover already is, and a return trip is generated by reversing the list and negating each turn, not by recording a coordinate to drive back to. That's a real, named limitation, not an oversight: dead reckoning drifts, and a long mission's actual stopping point will not match its predicted one.

The interesting part wasn't the step list. It was what had to be fixed in the rover's existing safety layer before it was honest to let that step list drive real motors with nobody standing there:

• Obstacle checking was off by default everywhere. The rover already had a depth-camera veto that refuses to drive forward into something close ahead — but it shipped disabled by default, because an operator once found it got in the way while driving manually with eyes on the video feed. That's a reasonable default for a human. It is not a reasonable default for a rover driving itself. The fix threads the caller's identity through the check so it is unconditionally on for anything the rover does under its own control, while a human driving manually gets the exact same behavior as before — same function, one new argument, zero behavior change for the case that already worked.
• A claimed race condition turned out not to exist. Reading a summary of the arbiter's code produced a plausible-sounding bug report: that overriding an in-progress autonomous move might not stop it cleanly before a new one started. Reading the actual fifteen-line function before writing a fix found the cancel call already sitting exactly where it needed to be — one line earlier than the summary had shown. Nothing was changed there. Worth stating plainly: a description of code is not the code, and the difference showed up on the first real read, not the tenth.

Every step during a mission also takes a real photograph and checks the rover's own wildlife-detection log for anything spotted during that step, both written to disk immediately — so a mission that never reconnects still leaves a complete record, rather than one that depends on a live link to be worth anything.

2. The model that earned a genuine "go" — on a computer six orders of magnitude bigger

Separately, and on entirely different hardware, a 1.4-billion-parameter model called Ouro was tested on a spare NVIDIA DGX Spark. Ouro's distinguishing property: it runs the same block of layers in a repeatable loop, and how many times it loops is a dial that turned out to be adjustable per question, not fixed when the model loads — the single fact the whole test existed to establish, confirmed by reading the model's own code rather than trusting its paper.

Latency scales almost exactly linearly with the dial; memory does not move at all. On a small head-to-head built from two of the shipped product's own real, previously-documented mistakes — reporting a transaction backwards, and echoing a prompt's own example back as if a customer had said it — Ouro got both right. The model already in production repeated its known direction-reversal error live, during the same test.

That result does nothing for Tark2 directly: the Spark it ran on is a full-size workstation GPU, not a rover's onboard computer, and getting Ouro's answers to a rover in the field means either carrying a live connection back to that Spark, or finding a model small enough to live on the rover itself. The install itself needed three small compatibility patches to the model's own published code before it would run at all under the installed library versions — a detail its own "already solved" framing had not anticipated, and worth recording exactly because it undercuts that framing rather than confirming it.

3. The smallest candidate for the rover itself didn't load

The natural next question: could something small enough to fit on the rover's own Jetson answer plain-English commands without needing that Spark connection at all? The candidate was Parcae-140m — a fraction of a gigabyte, chosen specifically for being the smallest model in its family, on the theory that if the software stack was going to break, better to find out on half a gigabyte than three.

It never got to loading. Parcae's own publisher ships it through a separate, from-source package rather than the ordinary format most models use — and that package requires a newer version of the Python language than the one already running this exact Jetson's camera and detection software, on a torch build that took real, hard-won work to get compatible with this board's specific graphics chip in the first place. Upgrading Python to satisfy one candidate model would mean redoing that compatibility work from scratch, on the live rover, with no guarantee the result would even be faster than the deterministic step sequencer it would be trying to improve on. That's a packaging mismatch, not proof that nothing this size can run on a Jetson — the next candidate just needs the same one-line check applied first: does it load through the ordinary library, or does it demand its own toolchain.

Before, during, and after the attempt, the live wildlife-detection service was checked directly — zero restarts, memory back to exactly where it started, every test file removed afterward. The rover's own working software was never at risk; the model just didn't fit.

4. What actually held up

The rover's autonomy shipped with no model in it at all, and that was the right call, not a placeholder for a smarter version later — a mission planned as turns and distances, run through a safety layer that was already sound apart from one default that needed flipping, does not need a language model to be useful. Separately, a real language model earned a real, numeric win on hardware built for it. The one place those two stories haven't met yet is the rover's own computer, where the smallest available candidate for bringing that intelligence on board turned out to need a toolchain this board doesn't have — a gap in packaging, checkable in five minutes against the next candidate, not a verdict on the idea.