The Linux firmware tree is not where anyone goes to watch a model show off. It is where laptop Wi-Fi, GPUs, DSPs, Bluetooth chips, modems, and other tiny silicon tenants get the binary payloads they need to wake up and behave. It is also, delightfully, where AI coding agents just got handed a rulebook that reads less like a manifesto and more like a stern shop note taped above the soldering bench.

On June 9, the linux-firmware project merged Josh Boyer's GitLab merge request adding AGENTS.md, a repository-level guide for tools such as Codex and Claude Code. Mario Limonciello merged it after CI passed. The commit is even co-authored by Claude Opus 4.8, which makes the whole thing feel like a robot writing the laminated safety card for other robots.

The interesting part is not that Linux maintainers are letting AI near firmware. The interesting part is what they are telling it not to do.

A Repository Where The Paperwork Is The Product

The new guide starts with a warning that matters. linux-firmware is not a normal software project. Most of its payload is binary firmware, not source built inside the repo. The core file is WHENCE, a hand-maintained manifest that records where every tracked file came from, what license covers it, and whether redistribution is allowed.

That flips the usual AI coding story sideways. In a web app, an agent might refactor a component, run tests, and ship a pull request. In linux-firmware, the agent's most valuable skill is not improvising code. It is following provenance rules without making stuff up.

The new rules are blunt:

  • Every file in git must be accounted for, almost always through WHENCE.
  • License files belong in LICENSES/ and are referenced from WHENCE, not smuggled in as ordinary firmware entries.
  • Agents must never invent license information.
  • They must preserve Signed-off-by: lines and not fabricate one for a human.
  • They must run make check before calling the job done.
  • They must not edit binary firmware contents.

That last one is the line with teeth. The guide says agents may add, move, link, remove, and document blobs. They do not modify blob contents. In other words: you can help organize the parts drawer, but you do not get to open the sealed chip.

The WHENCE File Becomes Agent Infrastructure

The most Linux part of the change is that AGENTS.md does not pretend agents need inspirational context. It gives them the operating order. Put firmware in the right vendor or driver directory. Add the WHENCE stanza. Add any new license text under LICENSES/. Run make check. Use the project's subject-line style. Include the legal and AI involvement trailers.

A simplified firmware entry has the flavor of a customs declaration:

Driver: qcom - Qualcomm platform firmware

File: qcom/example/device.mbn
Version: 1.2.3
Licence: Redistributable. See LICENSE.qcom for details.

The exact syntax is load-bearing because check_whence.py parses it. The same merge request adds AGENTS.md to that script's known_files allowlist, which is a tiny but revealing detail. Even the instruction file for agents has to be accounted for by the repository's own accounting system.

This is the useful version of AI process design. Not a chatbot floating above the repo, not a giant policy PDF, not a vibe-coded shrug. A file in the tree says: here are the buckets, here is the validator, here is what you must refuse to guess.

AI Help Is Welcome, But Put It In The Commit

The README change is just as important as the new agent file. linux-firmware now says AI-assisted contributions are welcome if the commit message clearly notes the tool or model with an Assisted-by: trailer, or a similar convention such as Co-developed-by:. That requirement sits beside the existing Signed-off-by: rule. It does not replace it.

That is the right split. Signed-off-by: is a legal attestation tied to redistribution rights. AI involvement is process provenance. Mixing those together would be a mess. Separating them makes the commit message tell two stories at once: who can vouch for the firmware, and what tool helped produce the patch.

The guide also tells agents to keep firmware changelogs in commit messages where possible. For blobs, that can be the only readable record of what changed. A binary diff may say almost nothing. The commit text may be the map.

Why This Is Bigger Than One AGENTS.md

Repository instruction files are spreading because agents are no longer just autocomplete with better manners. They open files, run commands, stage changes, and sometimes push toward merge-ready work. That makes local rules more important, not less.

The funny thing is that the best instruction files are often boring. They do not ask the model to be brilliant. They remove choice where choice is dangerous.

  • Do not guess a license.
  • Do not edit the blob.
  • Do not add tooling files to WHENCE just to silence a check.
  • Do not call validation complete until make check passes.
  • Do not hide AI assistance in the commit metadata.

That style matters because agent failures are rarely cinematic. The bad case is not a model inventing a kernel driver in a thunderstorm. It is a small confident mistake in a manifest, a missing license reference, a trailer that looks official but is not, or a test skipped because the tool thought the diff looked fine.

linux-firmware is a good early example because the stakes are specific. The repository distributes device firmware used by the Linux kernel at runtime. Its value comes from traceability. The agent file tells tools to serve that value instead of trying to be creative in the wrong layer.

The Takeaway

Linux did not just get a cute AI policy file. A core-adjacent infrastructure repo turned agent work into a narrow, auditable workflow: preserve provenance, expose AI assistance, run the same checks as humans, and keep your synthetic fingers out of the binary guts.

That is probably where serious AI coding help is headed. Less magic intern, more obedient power tool. The projects that benefit will not be the ones that let agents roam wildest. They will be the ones that give agents enough context to be useful and enough hard boundaries to stay out of trouble.

For linux-firmware, the rule is simple: Codex may help carry the boxes, but WHENCE still checks the labels.

Sources