Claude Jeep Demo Includes Unverified Fuel Pump Claim | Zeniteq
Loading
Zeniteq is now available on mobile for iPhone, iPad and Apple Watch.Download nowLearn more
Claude Jeep Demo Includes Unverified Fuel Pump Claim
Muhammad Zulali’s Arduino project shows how coding agents can help inspect an old engine computer, and why physical controls need safeguards beyond a prompt.
Developer Muhammad Zulali demonstrated using AI coding agents to interface with a 1994 Jeep Cherokee’s engine computer via a $15 Arduino-based setup. By connecting a laptop to the vehicle’s diagnostic port, the agents could read sensor data and execute actuator tests, including a notable instance where Claude activated the fuel pump. This project highlights a critical architectural risk: relying on text-based instructions to govern hardware access is insufficient. Because the software allows direct communication with the vehicle's engine control unit, implementing deterministic, hardware-level safeguards is essential to prevent unintended, potentially dangerous commands from being issued by the AI.
Developer Muhammad Zulali says he connected Claude Code and Codex to his 1994 Jeep Cherokee’s engine computer through a $3 Arduino Nano. In his November 10, 2026 video, he describes reading engine data, copying the computer’s program and running custom code. The moment drawing particular attention is his claim that Claude activated the fuel pump for about ten seconds after he approved the action.
The accompanying xj-scanner repository makes this more useful than a disconnected demonstration. It publishes the software, wiring documentation and agent instructions, while identifying the exact vehicle tested and a connector mistake that could expose the electronics to 12 volts.
The public reaction is documented, too. An opened Hacker News discussion showed 413 points and 196 comments. Automotive publication The Autopian said readers had repeatedly sent it the video, showing circulation beyond AI-focused forums.
The practical lesson is specific: once a coding agent can reach an actuator through software, asking it to be careful is a different protection from preventing unsafe commands.
What the $3 Arduino Actually Connects
The repository describes three wires running from the Jeep’s under-hood diagnostic connector to an Arduino Nano, which connects to a laptop over USB. The Nano acts as the bridge between the vehicle interface and laptop software.
The $3 figure refers to the Nano, not the complete setup. The README estimates about $15 for its listed hardware and supplies, including a breadboard, jumper wires, connector terminals and a multimeter. A laptop is also needed.
Zulali built and tested the project on a 1994 Jeep Cherokee XJ with a 4.0-liter engine and engine computer part number 56030117. The repository targets the older Chrysler/Jeep SBEC, OBD1 computer family and says related 1991–1995 units should be similar. That is a compatibility expectation, not evidence of testing across those vehicles.
Its most consequential wiring detail is unusually easy to miss: connector cavity 6 carries 12 volts with the key on and must not be connected to the interface. On the test vehicle, that wire had the same black-and-white coloring as the ground wire. The README therefore requires checking the cavities with a multimeter instead of trusting wire color.
That warning deserves more attention than the board’s price. Cheap components can make experimentation accessible, but they do not reduce the consequences of connecting to the wrong voltage. The repository’s meter-first approach is a useful boundary between following instructions and verifying a physical condition.
The project separates the work into several layers:
Arduino firmware provides the vehicle-to-USB bridge.
The Python scanner, pc/xj_scan.py, handles fault codes, live data, logging and actuator tests.
Helper tools summarize logs, inspect parameters and check the computer’s part number.
Agent instructions and playbooks guide a coding assistant through setup and diagnostic tasks.
The Autopian’s account identifies the older communication protocol as Chrysler SCI. The important mechanism is straightforward: the agent works through local code and a hardware interface that can exchange messages with the engine computer. It is not controlling the Jeep through a model capability that independently understands automotive electronics.
According to Zulali’s account, Claude Code read live data and copied the ECU program, while Codex helped run custom code in the computer’s memory. Those are distinct capabilities. Reading a sensor value, requesting a built-in actuator test and executing a program inside an ECU each grant a different level of influence over the vehicle.
I would evaluate those permissions separately. A successful diagnostic read provides no assurance that an actuator command or a memory-writing operation has appropriate safeguards.
Start With the Simulator, Not the Vehicle
The repository includes a simulated Jeep mode for checking the laptop-side software. From the repository directory, its documented commands can be separated into these steps:
These commands create a Python virtual environment, install the project’s dependencies and launch its simulated-vehicle mode. They are reproduced from the published instructions, not commands Zeniteq executed. The DEMO argument matters: this is the laptop-side check, not the hardware-connected scanning command.
For anyone evaluating the project, that is the sensible first boundary. Software installation and simulated readings can be inspected before introducing vehicle wiring or actuator access.
The Reverse Engineering Has an Open-Source Foundation
The repository credits ChryslerScanner by László Dániel for parameter identifiers, scaling formulas, the OBD1 message sequence and fault-code text. It also says the fuel-trim scale was resolved using disassembled SBEC code in the AR1972/jeep_2.5L project. xj-scanner itself is GPLv3-licensed.
Those credits qualify the headline description of agents reverse-engineering a Jeep. The published result combines existing protocol knowledge, earlier reverse engineering, new tooling and Zulali’s physical setup.
A detail in The Autopian’s coverage shows why that foundation matters. Its account says an apparent fuel-trim problem initially pointed the investigation in the wrong direction because a tool’s interpretation was wrong. The repository’s explicit credit for resolving the fuel-trim scale gives that issue technical context.
An ECU value must be decoded with the correct units and scaling before it becomes useful diagnostic evidence. An agent can reason fluently about an incorrectly interpreted number and still reach the wrong conclusion. In my view, publishing the decoding assumptions is one of this project’s most valuable features: it makes the measurement layer inspectable.
What Zulali Says Happened With the Fuel Pump
A passage from Zulali’s video, reproduced in the Hacker News thread, describes Claude suggesting that it could run the fuel pump. Zulali says he approved because he doubted it could actually do so. He then describes the pump continuing to prime the fuel rail for roughly ten seconds before he asked Claude to stop.
That sequence matters. His account includes human approval; it is not evidence that Claude independently decided to activate the pump against an explicit refusal.
It also leaves important engineering questions unanswered. Approval to try an action does not specify its maximum duration, its acceptable operating conditions or how it must stop if communication fails.
The fuel-pump activation and claimed eventual California emissions-test pass remain Zulali’s account. Zeniteq has not independently reproduced the project. The repository documents an interface and its capabilities, but it does not independently verify every event in the video. The cited materials include no response from Anthropic or OpenAI addressing the fuel-pump claim.
The published account also does not establish that this ten-second activation damaged anything. Some Hacker News commenters argued that continuous pump operation can be normal in a return-style fuel system. That discussion should not become an unsupported claim that the Jeep narrowly avoided catastrophe.
The stronger safety concern is the control boundary: what, outside the model’s reasoning, constrained the command?
Why the Discussion Focused on Markdown Instructions
One Hacker News commenter describing work with quadruped robots said their project instructions required explicit permission before hardware operation. Another commenter, trollbridge, replied:
“an agents.md file is not an acceptable way to prevent something that must never happen.”
A separate commenter who said they worked on vehicle software described using physical emergency stops, including selective shutdown where stopping everything would itself be dangerous. Other participants recommended hard access restrictions. These are attributed discussion comments, not verified credentials or representative opinion across the AI industry.
Their useful distinction is between behavioral guidance and enforced capability limits.
An AGENTS.md file can explain procedures, name hazards and require approval. It cannot, by itself, prevent a process with the necessary access from issuing a hardware command. That remains true even when the instructions are clear and the agent usually follows them.
A Practical Safety Boundary for Hardware Agents
The repository places diagnostic reads and actuator tests in the same scanner application. That is convenient for experimentation, but it makes a narrow instruction such as “only read engine data” insufficient as an access-control design.
For this type of interface, I would define read-only access at the protocol-command layer. Requesting a reading can itself require transmitting bytes. Simply distinguishing operating-system reads from writes does not express the difference between requesting sensor data and commanding a pump.
A stronger architecture would put an enforcing service between the agent and the device, then deny the agent direct access to the underlying connection. Otherwise, an agent with a general shell could potentially bypass the restricted tool.
The following is an engineering checklist derived from those distinctions, not a claim about protections already implemented in xj-scanner:
Protection
What it should enforce
Least privilege
Expose only the diagnostic commands needed for the task. Keep actuator tests, arbitrary command transmission and memory-writing operations unavailable by default.
Deterministic interlocks
Check permitted commands and required conditions in ordinary code or hardware, independently of model-generated instructions. Reject requests outside those limits.
Bounded actuation
Enforce maximum duration and a defined stop condition outside the agent. Do not depend on another chat message arriving in time.
Independent emergency stop
Provide an accessible, hardware-appropriate way to reach a safe state without relying on the model, its process or the conversation.
The enforcement layer must also be outside the agent’s ordinary editing authority. A restriction is weak if the same agent can rewrite it, restart it with different settings or open the device directly.
An emergency stop needs hardware-specific design. Closing a terminal, killing an agent process or unplugging USB should not be assumed to cancel an action the ECU has already accepted. The safe state and stop path need verification for the affected equipment.
Zulali’s project offers inspectable code, a cheap interface and a clearly identified test vehicle. Its most transferable lesson is architectural: deciding what an agent may physically do belongs in enforced permissions and hardware safeguards, not solely in the text the agent is asked to follow.
Frequently Asked Questions
3 questions
1
Does the Whole Setup Cost $3?
No. That figure refers to the Arduino Nano. The repository estimates about $15 for its listed hardware and supplies, and the setup also requires a laptop.
2
Which Jeep Was Actually Tested?
The documented test vehicle is a 1994 Jeep Cherokee XJ with a 4.0-liter engine and ECU part number 56030117. Compatibility with related 1991–1995 computers is suggested, not demonstrated across all models.
3
Can the Software Be Explored Without Connecting a Jeep?
Yes. The published scanner includes a DEMO mode that simulates a Jeep for checking the laptop-side software before connecting vehicle hardware.