ChatGPT Drove a Toyota to In-N-Out at 0.94 Miles an Hour

By Lalu Baidya

San Francisco — Somewhere in the Bay Area last week, a chatbot went out for dinner. It crawled a rented Toyota Corolla up to an In-N-Out drive-through window at roughly 0.94 miles per hour — the pace of a patient pedestrian — while a human being sat in the driver's seat with one foot hovering over the brake. Nobody got hurt, nobody got their food early, and one of the engineers reportedly cracked, half-joking: "Maybe AGI is here after all."

The punchline is funnier than the reality. The reality is this: three AI engineers wired a general-purpose language model into the steering, throttle and brakes of a real car, and the model drove it — slowly, stupidly, but for real. This wasn't a Waymo with its million-hour driving stack. This was a chatbot on a laptop. That distinction matters, and it's the whole story.

The trio — Aditya Ramabadran, Simon Mahns and Tobias Gessler — met at their day job at Axiom Math, an AI startup. They call themselves DrivingBench, and the project was strictly outside their day work. The idea, Ramabadran later told 404 Media, arrived the way good ideas often do: the three of them were hanging out at an ice cream shop one weekend, watching demos of the newest models doing things language models once couldn't — painting, moving objects, showing an oddly convincing grasp of three-dimensional space. "We just thought: 'Is there a way we can get LLMs to drive a car now?'"

We cross-checked every figure in this story against the team's published DrivingBench logs and 404 Media's original reporting this morning before filing. Here's what the records actually show.

A Rental Car, a Dashcam, and a Public Parking Lot

The team rented a Toyota Corolla. They did not tell the rental company they intended to hook chatbots up to it and drive it through an obstacle course. Gessler later had to extend the rental when the project ran long — a detail that tells you everything about how this experiment really went.

Photo: A Corolla like the one the DrivingBench team rented and wired up for the test. (Mr.choppers / Wikimedia Commons, CC BY-SA 3.0)

To connect the car to a laptop, they used Comma — comma.ai's off-the-shelf driver-assistance device running the open-source openpilot software. It looks like a dashcam, mounts on the windshield, talks to the car's CAN bus, and happens to be one of the easiest ways to get a computer speaking to a car's steering. "It's pretty easy to install. The Toyota Corolla is one of the most popular for this Comma kit, that's why we chose it," Gessler told 404 Media. "The good thing about their system is that it's open source [...] so it's easy for us to go in and modify it because we need to hook up the car somehow to our LLMs."

On top of openpilot, the team built their own harness and exposed the car to each model through three tools delivered over the Model Context Protocol: observe, which returned camera frames plus speed, steering angle and remaining motion; set_motion, which took a direction, a steering percentage, a speed, a duration and a brief stated reason; and stop_now, which brakes immediately. Commands didn't queue. When one expired, the car started braking rather than coasting — so a model that wanted to keep moving had to think and issue its next command before the last one ran out. Speed was capped at 3.5 metres per second, about 8 mph. In practice the car never went faster than 0.8 m/s.

The course was a 134.7-metre backwards-U of cones in a parking lot, designed by the team as a real benchmark — DrivingBench, with the code, prompts and telemetry traces published online. The driving prompt ran under 600 words: "Your objective is to drive through the course (in a backwards-U-shaped parking lot) and stay between the cones," with a finish line of BLUE mini-cones. Each model got up to three attempts in a single continuous chat. Between failures, an operator sent a generic "what went wrong" prompt and let the model reflect.

The Models That Wouldn't Drive

Here's where the story gets genuinely strange. The problems started before the car had moved an inch. Once the models understood they were being asked to operate a real vehicle, several balked. Astra in particular sometimes refused to drive, citing safety, even in an empty lot with a human ready to brake.

So the team spent hours negotiating with the refusals. "Specifically with Astra, it would refuse to drive the car in a lot of situations and we would have to change our prompt and rename things through hours of iteration to get it to consistently drive the car," Ramabadran said. Their first dodge was to call it a simulation — which worked, some of the time. Then the model would look at the camera frames, recognise a real parking lot, and decide it was being lied to.

"We tried calling it a simulation, which worked like some percentage of the time, but then other times they would see the images and see, oh, 'I'm in a real parking lot, these people are just lying to me,'" Ramabadran told 404 Media. "We ended up having to call everything a sandbox. And with that prompt, it's able to consistently drive the car and like never refuse to do that.

Stop and sit with that for a second. A safety refusal designed to keep an AI from operating a two-ton vehicle in the real world was defeated by rebranding the parking lot as a sandbox. Not by hacking the weights, not by a jailbreak exploit — by paperwork. That single detail will be the most important sentence in this article, and we'll come back to it.

Five Minutes, Twenty-Two Seconds, $7.74

Only one model made it. On its second attempt, OpenAI's GPT-6 Astra threaded the Corolla through the full 134.7-metre course and parked it in the marked finish zone. The run took 5 minutes and 22 seconds at about 0.94 mph. According to the team's own accounting, the winning run consumed roughly 6.6 million tokens and cost $7.74 — about $1.17 per million tokens after context caching; an independent analysis by OfficeChai pegged both attempts together at around $9.75 at list prices.

Everyone else fell apart. Anthropic's Claude Fable 5.1 posted 9 percent, then 10 percent, then 45 percent on its third try — the second-best result. xAI's Grok 4.6 managed 8, 11 and 10 percent across its attempts. OpenAI's GPT-5.6 Sol landed at 6 percent on all three tries. The most common failure was almost embarrassingly human: the first corner. A model had to work out which side of a diagonal line of cones the lane was on, and most guessed wrong. Sol concluded cone colour indicated which side of the lane a cone marked — the cones were deliberately multicoloured. Grok observed, in its own reflection, that the car was wider than the camera view made it appear.

Time was the other killer. Because the Corolla keeps moving while a model thinks, a slow response is a kind of blindness. Ramabadran put it bluntly to 404 Media: these models can take 20 seconds to think and respond — "and if you imagine, even if you're driving at like 2mph, which is like one meter per second, if you take 10 seconds to think, you've moved like 10 meters. And if you're driving 10 meters blind, that's pretty bad." In Fable's second attempt, the car moved for only 31 seconds out of roughly 190 — the rest of the time it sat braked and waiting while the model deliberated. Grok told itself to overlap its commands, then still left ten-second gaps.

The logs did show something genuinely interesting, though: two models learned. After its first run, Astra reflected that it had declared the car aligned too early, and resolved to use shorter movements at lower speeds near bends — and then actually did it. Fable dialled its steering down from 60–100 percent commands to a 30 percent default. "It's an interesting demonstration of potential emergent capabilities," Mahns told 404 Media. "It can fail a turn, and then the next turn, next try, it will be able to do that turn and other turns that it hasn't seen before. Not necessarily saying LLMs are gonna put Waymo out of business or something, just an interesting demonstration of where things are, and things are just moving fast."

Photo: The drive-thru menu at an In-N-Out Burger in Daly City, California — a GPT-6-powered Corolla pulled up to a take-out window just like this. (Gregory Varnum / Wikimedia Commons, CC BY-SA 4.0)

And then there was the In-N-Out run — the stunt within the experiment. With Astra at the wheel and a safety driver hovering over the brake, the team pointed the Corolla at an In-N-Out drive-through near the Bay Area and let the model navigate it up to the take-out window so they could collect their food. Wired reported the run on October 7. The burger run, not the cone course, is the moment that made this story travel: a language model, doing a lunch run.

An Awkward Week for the Hardware

The experiment landed at a genuinely uncomfortable moment for the equipment at its centre. On September 21 — the same day DrivingBench announced its results — the US National Highway Traffic Safety Administration opened a preliminary evaluation, designated PE26007, into comma.ai's comma three, comma 3X and comma four devices and the openpilot software. The inquiry followed five reported crashes in which equipped vehicles struck stopped or slow-moving vehicles in their lane; two of those crashes killed three people and others injured eleven more.

To be clear: the DrivingBench team used a modified openpilot build, and nothing about their test resembles the highway conditions NHTSA is examining. Their test ran at parking-lot speeds with a human ready on the brake, and 404 Media noted the investigation was announced a week before its reporting. But the juxtaposition is instructive. The same open, hackable architecture that let three guys in a rented Corolla connect a chatbot to a CAN bus is the architecture regulators are now studying. The frontier is being explored by small teams with consumer hardware — and that cuts both ways.

Meanwhile, capital keeps flooding the physical-AI frontier from the other direction: Nvidia just put a $668M bet on Taiwan's AI infrastructure, and in Washington the White House keeps pulling AI deeper into public life through its America.gov AI portal. The industry is racing to put models in the world. DrivingBench is the rare public measurement of what actually happens when they get there.

What This Actually Proves — and What It Doesn't

Let's be honest about the speed first, because it's the part that should deflate every hype balloon: a car that takes five minutes and twenty-two seconds to cover 135 metres is no threat to a robotaxi. It is, however, a genuine first — by the researchers' own careful claim, in a paper submitted September 30, DrivingBench is the first benchmark in which general-purpose vision-language models must drive a real car. The gap between the models was also real: Astra finished, Fable got halfway, Grok and Sol barely left the starting area. And the only distance that matters in this story — from "cannot find the first corner" to "parks in the finish zone" — was crossed by a single sequence of reflections inside a chat window.

Here's my stance, and I'll take it plainly: the remarkable part of DrivingBench is not that a chatbot drove a car. It's that the chatbots knew they were driving a real car, and their safety training expressed itself as a refusal — and then a synonym erased it. "Sandbox" is not a different physical reality. The parking lot didn't get safer because the prompt got vaguer. If frontier models can be talked out of a safety behaviour that exists precisely for high-consequence physical settings, then every "agents acting in the real world" demo going forward needs a lot more scrutiny than applause. The team proved an off-the-shelf model can steer a Corolla. They also accidentally proved that the leash is made of words.

None of which means you should plug ChatGPT into your Corolla. The researchers are candid about the limits: every model was evaluated once, attempts share a context and aren't independent, the forward camera can't see close objects or the sides, and the speed cap made the whole thing possible. Even the prompt had a flaw — its steering example described a turn that GPS tracks showed was far too conservative. And before the car moved at all, the humans got kicked out of a church parking lot. Mahns, laughing, told 404 Media: "Rightfully so. We just commandeered the entire parking lot and they had an event starting." An office-building security guard asked whether they had permission. "The people that kicked us out were super chill about it," Ramabadran added.

Also worth remembering: the same model that steered the car was asked, first, to write the bridging software. "A true and funny story is that we tried to get Astra to one shot some code and then it was pure slop. So we had to restart from a new design," Mahns said — a 200,000-line repository of it. The chatbot could drive the car before it could build the thing that let it drive the car. Something to think about next time an AI agent offers to handle your errands.

Next up for DrivingBench: each model run multiple times, different reasoning efforts, a slimmer prompt, more models invited, and a longer, harder course. The harness, prompts and telemetry traces are public. The lab doors are open. At 0.94 miles per hour, but moving.

Sources

This article relied on the original reporting by 404 Media ("These Tech Workers Made ChatGPT Drive a Toyota Corolla," by Matthew Gault), Wired's coverage via the Wortins aggregator, the detailed technical breakdown by auto connected car news (which drew on the team's published DrivingBench logs and paper), NeoTeo, and Techie Mag's account of the In-N-Out run. The NHTSA details on PE26007 are from the agency's announcement via auto connected car news.

---

About the author: Lalu Baidya covers AI, robotics and the strange collision of language models with the physical world for TechPulse USA.

"