Skip to content

AI·News & analysis

A 1994 Jeep failed its smog test, so AI agents reprogrammed its computer

Muhammad Zulali used Claude Code, Codex and a $3 Arduino board to read and rewrite the engine computer of his 32-year-old Jeep Cherokee, and it passed California's smog test.

Dan KostBy Dan Kost aka Poseidan8 min readX
A laptop on the hood area of the Jeep showing Claude Code logging live engine readings

Tide

Ripple

Sci-fi

6/10

Reality

In your hands

A 1994 car computer meets an AI agent. Neither has met before.How we rate

The Squeeze

YouTuber Muhammad Zulali used Claude Code and OpenAI's Codex to reverse engineer the engine computer of his 1994 Jeep Cherokee, and the SUV then passed California's smog test.

The agents found that the California-only program cuts fuel under the exact loads the test uses, then rewrote the computer's memory. The hardware cost about $15 and the work took about a week. Zulali published the wiring and code as xj-scanner, so other owners can try it at their own risk.

What to know

  1. Muhammad Zulali's 1994 Jeep Cherokee kept failing California's smog test because of high nitrogen oxide (NOx) at 25 mph.
  2. A $3 Arduino Nano, a breadboard and three wires let Claude Code talk to the Jeep's engine computer, for a total of about $15 in parts.
  3. Claude copied the computer's 32KB program and found that the California version cuts fuel under the exact loads the smog test uses.
  4. Codex wrote a small program straight into the computer's permanent memory, and the Jeep passed. The code is public on GitHub.

A YouTuber's 32-year-old Jeep kept failing its smog test, so Muhammad Zulali handed the problem to AI agents. They read the car's computer, found the cause and rewrote part of it.

That's the news. Now the fun part: how do you talk to a computer from 1994 when it has no modern plug at all?

What was wrong with the Jeep?

Zulali's 1994 Jeep Cherokee failed California's smog check. He needed a pass to renew the registration.

The problem was high NOx at 25 mph. NOx is short for nitrogen oxides, gases that form when an engine burns fuel very hot. Mixed with other pollutants and sunlight, they turn into smog.

California runs a tailpipe test on cars built before 1996. It measures five gases, including NOx, while the car runs on rollers. Newer cars skip that and get plugged into a diagnostic check instead.

Zulali tried a few fixes by hand. After he adjusted the oxygen mix, the Jeep failed at both 25 mph and 50 mph. It got worse.

He was adjusting blind, and each official retest cost nearly $100. That is the point where he asked an AI for help.

Claude reverse engineered my 32-year-old Jeep. Then it started controlling it. · Video: Muhammad Zulali

Why is an old car computer so hard to read?

Modern cars have a standard diagnostic port. A mechanic plugs in a scanner and reads fault codes and live data. Cars before 1996 do not have that standard.

The Jeep's engine computer, often called the ECU, uses a slow serial link called SCI. Its signal is also electrically inverted, which means highs and lows are flipped compared with what a laptop expects. A laptop cannot read it directly.

So Claude Code told Zulali to build a translator. It was a $3 Arduino Nano, a tiny programmable circuit board, on a breadboard (a plastic board for wiring parts without soldering). Three wires ran from the Jeep's six-pin diagnostic plug to the board. The board then connected to his MacBook over USB.

In real life Think of the Arduino as a travel interpreter. The Jeep speaks an old dialect, the laptop speaks modern English, and the little board repeats everything in the right direction.

Zulali removed one resistor that was drowning out the signal. At 1:30 a.m. the setup pulled its first live readings. "It was the first time that Claude actually read something on this archaic computer," he said.

What went wrong along the way?

The first data looked odd. The computer seemed to be adding 22% extra fuel. That did not fit with a car that had too much NOx, which usually points to too little fuel.

After a logging drive at night, Claude found the reason. An open-source tool already online had the formula backward. The Jeep was actually removing 22% of its fuel.

"That was the first time Claude got something wrong," Zulali said. He added that the mistake came from the tool online, not from Claude itself.

The catch: An AI agent is only as good as the data it is handed, and this one was handed a backward formula. A human had to notice that the story did not add up.

What did Claude find inside the computer?

To see why the car cut fuel, Claude copied the computer's whole 32KB program onto the laptop. That is a tiny amount by today's standards, smaller than one phone photo.

Reading it turned up a California-only quirk. The version of the program built for California emissions rules cuts fuel hard under the same engine loads the smog test uses. That produces a lean mixture, and a lean mixture makes extra NOx.

The car was not exactly broken. It was following its own California instructions a little too strictly at the one moment the test was watching.

Why couldn't they just reflash it?

The obvious fix was to load the standard "Federal" fuel settings, which do not cut fuel the same way. Claude built a full kit for that and made a backup of the computer first.

The hardware said no. "My computer was made in December of 1993, about four months before they started making these computers programmable," Zulali said. It did not have the parts to enter reflash mode.

Reflashing means replacing the firmware, the built-in software that runs a device. On this early unit that path was physically closed.

How did Codex get around that?

This is where OpenAI's Codex stepped in. It found a way to send a very small program over the same three-wire connection, and the 1994 computer simply ran it.

There was one more hurdle. The computer's short-term memory, its RAM, wipes the custom code every few seconds. So Codex wrote the program into the EEPROM, a memory chip that keeps its contents even when the battery is unplugged.

Zulali split the credit this way: "Claude did most of the diagnostic work and Codex did pretty much all of the memory work. I just did the wiring and the driving."

He also said he did not need a mechanic or a Chrysler dealer tool. After the change, the Jeep passed the California smog test.

What does the project cost, and who can use it?

Zulali published the project as xj-scanner under the GPLv3 license, a free software license that lets anyone reuse and share the code. Parts came to no more than about $15.

Here is what the repository includes:

  • The Arduino sketch: the small program that turns the Jeep's signal into something a laptop can read.
  • A scanner program: it reads fault codes, shows live data, logs drives and runs the computer's built-in tests.
  • Helper tools: they summarize a log and check the computer's part number.
  • Wiring guides: step-by-step notes for the plug, the protocol and each reading, written so an AI agent can walk you through them.

The project was built on one car, a 1994 Cherokee XJ with the 4.0-liter engine. It says other 1991 to 1995 Chrysler and Jeep computers of the same family should be close, but you must measure your own plug before connecting anything.

One warning is printed in bold: cavity 6 of the plug carries 12 volts with the key on, and nothing should ever be connected to it. On the test car its wire is the same color as the ground wire, so color alone is not safe.

Why does this story matter beyond one Jeep?

The Cherokee XJ is a popular old SUV. It was built from 1983 to 2001, with about 3 million made around the world, and it still has a loyal fan base and a big aftermarket.

Plenty of owners run into the same wall: a car old enough that dealer tools have gone, and young enough to need an emissions pass. An agent that can read an unfamiliar machine and write code for it changes how hard that is.

Zulali's own summary is about the bigger idea. "This is the first time that an agent could go inside of the computer, make changes, and we could see the changes itself," he said. He asked what else people might plug an agent into.

Why it matters: The agents did not just give advice. They read data, ran the tests and wrote code that went inside the machine. That is what makes the AI agent idea different from a chatbot, which only answers questions.

What it means for you

  • Old gadgets get a second life: an AI agent plus a cheap board can make sense of hardware that has no manual and no modern port.
  • Check the AI's inputs: the one big error here came from a tool online, so verify numbers before trusting any diagnosis.
  • Be careful with cars: this is a hobby project, and it changes how an engine runs. The author says to use it at your own risk.
  • Know your local rules: emissions settings are regulated, so check what is allowed where you live.

The bottom line

A man with a failing Jeep, a $3 board and two AI agents got a 1994 computer to talk and then to change. It took about a week and about $15 in parts.

It is a small story with a big hint in it. The next time something old will not talk to something new, an agent might be the interpreter.

Key facts

Car
1994 Jeep Cherokee XJ, 4.0L, computer 56030117
Hardware
$3 Arduino Nano, about $15 in total
Time
About a week
AI agents
Claude Code and OpenAI's Codex
Code
xj-scanner on GitHub, GPLv3 license

Got questions?

Quick answers, plain words

Which car was it?

A 1994 Jeep Cherokee XJ with the 4.0-liter engine. The project page names its engine computer as part number 56030117.

Who did this?

Muhammad Zulali, a YouTuber. He published a video about it on November 10, 2026, and put the wiring and code on GitHub.

Why did the Jeep fail the smog test?

It made too much nitrogen oxide (NOx) at 25 mph. NOx is a pollutant that forms when fuel burns very hot, and it is one of the five gases a California smog test measures.

What did the Arduino do?

It acted as a translator. The Jeep's computer speaks a slow, inverted serial signal that a laptop cannot read, and the $3 Arduino Nano converted it into something a laptop understands over USB.

Why not just reflash the computer?

Reflashing means loading new software onto it. Zulali's computer was built in December 1993, about four months before Chrysler started making them reprogrammable, so it lacked the parts to enter that mode.

What did Codex do?

It found a way to send a tiny program over the three-wire connection that the computer would run. It then wrote a real program into the EEPROM, a memory chip that keeps its contents with the battery unplugged.

How much did it cost?

The parts came to no more than about $15, according to Zulali. Each official smog test he paid for cost nearly $100.

Did the AI make mistakes?

Yes. Early on, Claude read that the computer was adding 22% fuel. It turned out an open-source tool online had the formula backward, and the computer was removing 22%.

Can I do this to my car?

The xj-scanner project covers 1991 to 1995 Jeeps with similar computers, but it was tested on one car only. Its author calls it a hobby project used at your own risk.

Is it legal to change emissions software?

The sources do not say. Zulali's goal was to make the Jeep pass the official test. Check your local rules before changing any emissions-related settings.

SourcesMuhammad Zulali (xj-scanner)
Topics and tagsOpenAI, Anthropic, AI agents, claude code

Get the next one in your inbox.

AI, tech and robots in five minutes. Free, every morning.

Go deeper

Guide, 8 minHow to pick a Claude model and plan: Sonnet 5.5, Opus 5.5, Pro and MaxChoose between Claude Sonnet 5.5 and Opus 5.5, read your usage meter, and understand what independent testing says about how far a Claude...

More in brief