Muhammad Zulali published xj-scanner on GitHub and a November 10, 2026 YouTube walkthrough showing Claude Code and OpenAI Codex working through a 1994 Jeep Cherokee engine computer that has no OBD-II port. Over roughly a week, the agents helped build a $3 Arduino Nano serial bridge, read live SCI data, log drives, run actuator tests (including briefly energizing the fuel pump), copy the full ECU program to the laptop, and—per Zulali’s account—have Codex persist custom code in EEPROM on hardware too old to reflash conventionally. If you run Claude Code, Codex, or Cursor with shell access, the security takeaway is not “cars are hacked now.” It is that the same approval loop you use for rm -rf and curl | bash now sits in front of irreversible physical actions when someone clones an agent-ready hardware repo.
TL;DR
| Question | Answer |
|---|---|
| Am I affected? | Only if you use coding agents with Bash/serial upload on embedded, OT, or vehicle-adjacent projects—or you auto-approve edits in repos with AGENTS.md skill playbooks. |
| Is there a CVE or patch? | No. This is an open-source hobby project (GPLv3), not a vendor advisory. Mitigation is process and permissions, not npm update. |
| What did the agents actually do? | Read/log SBEC data, correct bad third-party scaling, actuate fuel pump, dump firmware, and—per the owner—run Codex-supplied code in ECU memory. |
| Who verified it? | Owner-reported on one 1994 XJ; the README warns at your own risk and says the author is not a mechanic. |
| Does data leave my machine? | Model providers see your agent thread when you use cloud models; the serial bridge is local USB. See Anthropic’s Claude Code security guide. |
| What should I do today? | Review actuator/upload commands, don’t run hardware agents from Downloads, scan AGENTS.md and skills, and use enforce policy where your harness supports it. |
What shipped (primary sources)
The repo README (November 2026) states the goal plainly: read a 1991–95 Jeep engine computer from a laptop and let an AI agent do the reading. Three wires run from the under-hood diagnostic plug to an Arduino Nano; the Nano connects over USB; Claude Code, Codex, or any coding agent can then read fault codes, stream live data, log drives, and run the ECU’s built-in tests.
Tested configuration on the README:
- Vehicle: 1994 Jeep Cherokee XJ, 4.0L
- ECU part number: 56030117
- Parts budget: about $15 (Nano, breadboard, jumpers, spade terminals, multimeter)
- License: GPLv3, with parameter tables credited to ChryslerScanner by László Dániel and disassembly notes from AR1972/jeep_2.5L
The “easy path” is intentionally agentic: clone the repo, open it in your coding agent, and say “Help me hook this up to my Jeep.” The agent is expected to read AGENTS.md and .claude/skills/ playbooks, then walk through software setup, breadboard wiring, plug pinout verification, and the first reading.
Zulali’s YouTube description (same date) adds timeline color the README does not spell out: smog failures at 25 mph NOx, swapped O₂ sensor made results worse, ~$100 per smog attempt, first successful live read around 1:30 a.m., a logging drive that exposed wrong fuel-trim interpretation, firmware copy revealing a California-specific fuel table, and Codex handling EEPROM persistence when December 1993-built hardware could not enter reflash mode. Secondary outlets—including Cyber Security News on November 16, 2026—repeat those owner claims; we treat them as documented by Zulali, not as independent lab reproduction.
Attack chain for a coding-agent operator (step by step)
This is not a malicious chain—it is the legitimate workflow xj-scanner encodes. Security teams should recognize the same stages when attackers reuse agent harnesses against other embedded targets.
1. Problem framing in natural language
Zulali started with a concrete failure mode (high NOx at smog speeds) and no compatible scan tool. He delegated protocol discovery to Claude Code instead of a legacy Chrysler shop tool.
Agent-security note: the initial prompt is trusted user intent—but once the agent browses public repos and parameter tables, untrusted third-party data enters the context (similar to supply-chain mistakes in other agent RE work).
2. Physical translator under agent direction
The Jeep’s SCI bus is slow and uses an inverted serial line. The project’s Arduino sketch (arduino/xj_bridge) plus docs describe turning a $3 Nano into a translator. Coverage cited in Cyber Security News mentions roughly 7,800 baud and only three of six diagnostic holes used—while cavity 6 is 12 V keyed power that can fry the board if misidentified (the README insists on metering every cavity, not trusting wire colors).
3. Read-only telemetry, then interpretation risk
First live values were limited (coolant, battery). Later parameters looked like +22% fuel trim until the agent reconciled readings with fuel pressure (~10 PSI in reported testing) and traced the mismatch to ChryslerScanner scaling—a reminder that agents amplify bad open-source constants, not just bad model outputs.
4. Crossing from observation to actuation
Reported milestone: Claude commanded an on-demand fuel pump run (~10 seconds). That is the session pivot from passive logging to outputs that move fuel and pressure—the same class of risk as approving kubectl delete or aws s3 rm, except the actuator is mechanical.
The shipped CLI supports built-in tests; from the README, a typical laptop-side check before hardware is:
python3 -m venv .venv && .venv/bin/pip install -r pc/requirements.txt
.venv/bin/python pc/xj_scan.py --cli DEMO
Uploading the bridge sketch uses arduino-cli against a real serial port—another irreversible command class agents propose in one line.
5. Firmware extraction and memory execution
After copying the full ECU program to the laptop, Zulali’s account describes California-only fuel mapping that cuts fuel under smog-test loads—plausible root cause for lean-running NOx, but still owner diagnosis.
When reflash hardware was unavailable (ECU stamped December 1993, before reflash-capable boards), Codex reportedly:
- Sent a small program over the existing diagnostic link.
- Lost it when RAM cleared within seconds.
- Moved persistence to EEPROM, which survives battery disconnect.
That is the headline for security readers: agent-assisted on-device execution on safety-related firmware, without a dealer tool chain—on hardware predating modern OBD standards.
6. Open publication and agent cloning
The repository includes agent instructions, skills, Python tooling, and Arduino firmware under GPLv3. Anyone with a similar Chrysler/Jeep can fork the playbook—benign for XJ enthusiasts, dual-use for anyone studying how little bespoke tooling embedded attacks now need when a coding agent drives the loop.
What this means if you run AI coding agents
Treat hardware repos like production infrastructure
xj-scanner is not malware, but it demonstrates the AGENTS.md hijack pattern in reverse: intentional instruction files steer the agent. If you work on robotics, medical devices, PLC glue code, or automotive aftermarket tools, assume contributors will add skill playbooks and expect auto-execution.
Checklist:
- Start agents in the project root you trust, not
~/Downloadsor a parent directory with stray instruction files. - Diff
.claude/skills/, AGENTS.md, and hook configs after anygit pull—the README tells users to let the agent lead setup. - Require human eyes on
arduino-cli compile --upload,minicom,screen /dev/tty*, or any script that toggles actuators. - Separate API keys from bench laptops that can reach USB serial devices; stolen keys plus agent automation is the LLMjacking pattern with a new actuator layer.
Permissions are the real control plane
Anthropic’s security documentation is explicit: you review proposed commands; Manual mode prompts on edits and most Bash; Auto mode routes some decisions to a classifier. None of that knows whether approving xj_scan.py will spin a fuel pump—it only sees text.
Map vendor guidance to your bench:
- Prefer Manual or tightly scoped allowlists when a repo mixes Python + firmware upload + hardware tests.
- Use sandboxed Bash where your harness supports it for untrusted forks—but remember USB serial devices often live outside filesystem sandbox boundaries.
- Run
/security-review(documented in the same guide) before merging agent-generated changes to bridge firmware or parameter tables.
Wrong tools propagate faster with agents
The fuel-trim episode mirrors false positives and wrong constants in agent-driven security audits: the failure mode was a public parameter table, corrected only because the human kept measuring the car. For your team, log which upstream CSV, skill, or MCP tool supplied each constant agents paste into production code.
Dual-use and physical access
Industry history already showed that with workshop access, ECUs and CAN buses can be abused to affect brakes, throttle, and steering. Agents do not create that physics—they compress time-to-working-protocol for engineers who are not career automotive reverse engineers. The Intezer and REA MCP story is the software-side parallel; xj-scanner is the garage bench version with real actuators.
Offensive researchers and agentic pentest frameworks catalogued this fall are converging on the same harness shape: orchestrator + tools + approval fatigue. Your defense is not “ban Claude.” It is narrow approvals, evidence logs, and separating OT USB paths from cloud keys.
How Beam handles this
Beam is built for local observability and policy on coding agents, not for sandboxing your Arduino. Where it helps on a project like xj-scanner:
- PreToolUse hooks on Claude Code and Codex can deny risky shell patterns when workspace policy is cached in enforce mode—useful for blocking unreviewed
curl | bashor destructive paths while you still manually gate upload commands (how Beam wires PreToolUse). - Heuristic scans of skills and MCP configs (11 patterns plus MCP version-pin checks) catch known-bad shapes before you run cloned playbooks from
.claude/skills/. - On-device storage with redaction before persistence keeps actuator-test logs local, which matters when logs contain VIN-adjacent data or bench identifiers.
Limits to state plainly: Beam does not sit on the CAN/SCI bus, does not validate electrical wiring, and fails open if cached policy is missing. It will not stop a fuel-pump test you explicitly approved in the agent UI—that is still your call, backed by permission docs you configure in the agent.
Claimed vs verified (read this before you fork)
| Claim | Status in sources we used |
|---|---|
| Claude Code/Codex read live SBEC data via Arduino bridge | Documented in GitHub README + owner video description |
| Agents corrected ChryslerScanner scaling | Reported by owner; repo credits ChryslerScanner tables |
| Fuel pump actuation test | Reported by owner and Cyber Security News citing the video |
| Full ECU program copied to laptop | Reported by owner; not independently verified here |
| Codex code running from EEPROM after RAM wipe | Reported by owner; not lab-reproduced in sources we checked |
| Vehicle passed California smog after changes | Claimed in Cyber Security News citing Zulali; not independently verified |
| Safe for all 1991–95 Chrysler/Jeep ECUs | Not claimed—README says “close” family match, measure your plug |
Zulali’s video description says he is not a mechanic and some engine explanations may be wrong. Treat fork-and-try like any unvalidated aftermarket tune: wrong EEPROM writes can brick an ECU or create emissions/legal issues, independent of AI.
Frequently asked questions
What is xj-scanner?
xj-scanner is the GPLv3 GitHub repository MZULALI/xj-scanner. It wires a 5 V Arduino Nano to a 1991–95 Jeep or Chrysler SBEC diagnostic plug, runs Python scanner code on a laptop, and ships AGENTS.md plus .claude/skills playbooks so Claude Code, Codex, or another coding agent can walk an owner through setup, live data, logging, and built-in actuator tests.
Is Claude Code an AI agent?
In Anthropic’s terminology, Claude Code is an agentic coding tool: it proposes shell commands, edits files, and uses tools in a loop until you approve or deny each action. The xj-scanner README explicitly tells you to open the repo in Claude Code or Codex and ask the agent to help with wiring and readings.
Is Claude Code or Codex better for xj-scanner?
Zulali’s published account and Cyber Security News coverage attribute most diagnosis and protocol work to Claude Code and the EEPROM execution problem to Codex. The repo itself does not require one vendor—you clone it and use whichever coding agent you already run, following AGENTS.md.
Did the AI really run code inside the Jeep ECU?
According to Zulali’s November 10, 2026 video description and secondary reporting that cites it, Codex found a way to send a small program over the same three-wire diagnostic link and persist it in EEPROM after RAM was wiped within seconds. That claim comes from the owner’s documentation; it was tested on one 1994 Cherokee XJ 4.0L and has not been independently reproduced by a third-party lab in the sources we checked.
Can anyone use xj-scanner on their car?
The README targets 1991–95 Chrysler/Jeep SBEC family computers and warns you to measure the diagnostic plug before connecting anything. Cavity 6 is 12 volts with the key on and can destroy boards if mis-wired. The project is a hobby build at your own risk, tested on one vehicle (ECU part number 56030117 in the README).
What went wrong with the fuel trim readings?
Coverage of the project states that live data first looked like +22% fuel trim until Zulali and Claude traced the mismatch to ChryslerScanner parameter tables (credited in the repo). The ECU was reportedly removing fuel, not adding it—wrong scaling from a public tool, not a model hallucination in isolation.
Is it safe to let a coding agent control car hardware?
Anthropic’s Claude Code security documentation says you are responsible for reviewing proposed code and commands before approval, and it recommends VMs for untrusted tool chains. xj-scanner includes actuator tests (for example switching the fuel pump) that move the session from read-only diagnostics to physical effects. Treat those Bash and upload steps like production changes.
What should developers running coding agents do after this story?
Segregate hardware repos from production API keys, read AGENTS.md and skill folders before auto-approving edits, keep Manual or reviewed Auto permission modes for serial upload commands, and log which agent proposed each actuator test. Local observability on the agent runtime helps when the blast radius is a vehicle, a factory line, or a USB-connected test bench—not just git push.
Related reading
- Intezer AI reverse engineering and REA MCP — software-side agent RE harnesses
- Malicious AGENTS.md in Downloads — instruction-file steering without consent
- GitGuardian on agentic pentest frameworks — same orchestration pattern, different intent
- Recorded Future on AI incidents and coding tools — broader incident context
- What Beam watches on coding agents — local flags vs vendor model safety
- Primary: MZULALI/xj-scanner
- Primary: Muhammad Zulali, YouTube walkthrough (Nov 10, 2026)
- Primary: Claude Code security
Parameter tables, Arduino tooling, and agent permission behavior are accurate as of November 16, 2026. xj-scanner is a third-party hobby repository; Beam does not endorse modifying emissions hardware where law prohibits it.

