01Forensics used to require inference
Digital forensics is the business of reconstructing intent from residue. Shell history tells you a command ran. Prefetch tells you a binary executed. A jump list tells you a file was opened. None of them tell you what somebody meant, and a good chunk of an examiner's job is arguing that inference convincingly.
Local LLM tooling broke that. When somebody designs a tool by talking to a model on their own machine, the conversation is the design document. It is written in plain language, it is timestamped, it states the objective explicitly, and in most default configurations nothing ever clears it.
The uncomfortable part
Shell history proves a command ran. A prompt history explains why it was written, who it was aimed at, what the author was worried about, and frequently includes the passphrase they chose, because they pasted it in to get help with the encryption call.
02What it looks like when it goes wrong
The cleanest illustration I have come across was a forensics challenge, Whisper, in the BlackHat MEA 2026 qualifiers. The scenario is mundane on purpose: a Linux workstation, an insider who used a local LLM to build an exfiltration tool. No memory corruption, no exotic cryptography. The entire thing is artifact retention.
Three failures compose, and all three are default behaviour rather than mistakes:
One: the prompt log is plaintext and permanent
~/.ollama/history is never cleared. It held a step-by-step statement of intent and the passphrase, typed directly into the chat because that is how you ask a model to help you write an encryption routine.
$ grep -riE 'pass|secret|key|exfil|upload' ~/.ollama/history
...write a python script that zips /data/reports and encrypts it with
the password Gr33nF0x42!D1amond using pyzipper, then uploads it to...In an interview that line takes an hour to establish. On disk it took one grep.
Two: "delete after execution" meant "move to Trash"
The tool was supposed to remove itself. It was implemented as a move to the desktop Trash, which is not a delete. The script survived intact, next to a .trashinfo file recording the original path and the deletion timestamp:
$ ls ~/.local/share/Trash/files/
cache_mgr.py
$ cat ~/.local/share/Trash/info/cache_mgr.py.trashinfo
[Trash Info]
Path=/home/dwright/.local/bin/cache_mgr.py
DeletionDate=2026-08-14T23:41:07That file gave up the key-derivation function and the staging path. Note what the .trashinfo adds on its own: original location and a deletion time, which is a timeline entry you did not have to reconstruct.
Three: the staging directory was a cache nobody cleans
The archive was still sitting there. Cache directories are excluded from backup policies and from tidy-up habits alike, which makes them an excellent place to stage data and a terrible place to hide it.
THE INSIDER DELETED THE SCRIPT
THE MODEL KEPT THE CONVERSATION
The forensic path is almost comically short: grep the prompt history for intent, recover the script from Trash to learn the key derivation, find the archive where the script says it staged it, derive the password, open it. The technique is not the interesting part. The interesting part is that the most incriminating artifact on that disk was created by a productivity tool, silently, as a feature. The full writeup is here.
03Where these artifacts live
If you do incident response, these belong on your collection list. Exact paths move between versions, so treat this as where to start rather than as gospel:
| Tool class | What to collect |
|---|---|
| Ollama and similar local runtimes | ~/.ollama/: prompt history, model manifests, pulled-model inventory (which model, and when) |
| Editor AI assistants | Workspace-scoped chat transcripts and index caches in the editor profile directory |
| Shell AI wrappers | Suggested-command logs, usually beside normal shell history |
| Desktop LLM clients | Local SQLite conversation stores plus attachment caches |
| Agent frameworks | Run traces, tool-call logs, intermediate scratch files |
A triage pass worth running early on a Linux host:
# 1. local model tooling present at all?
ls -la ~/.ollama/ ~/.cache/lm-studio/ ~/.config/*copilot* 2>/dev/null
ls -la ~/.ollama/models/manifests/ 2>/dev/null # which models, pulled when
# 2. the prompt history itself
grep -rilE 'password|passphrase|secret|api[_-]?key|token|exfil|upload' \
~/.ollama/ 2>/dev/null
# 3. SQLite conversation stores used by desktop clients
find ~ -maxdepth 6 -name '*.sqlite' -path '*hat*' 2>/dev/null
find ~ -maxdepth 6 -name '*.db' -newermt '-30 days' -path '*ai*' 2>/dev/null
# 4. the deletes that were not deletes
ls -la ~/.local/share/Trash/files/ ~/.local/share/Trash/info/ 2>/dev/null
# 5. staging directories nobody tidies
find ~/.cache -type f -size +1M -newermt '-14 days' 2>/dev/null | head -50Two properties make this material unusually valuable. It is narrative, so it describes intent directly instead of requiring you to argue for it. And it is pre-redaction: people paste real credentials, real hostnames and real customer data into a model they believe is private because it is local.
04The same thing, from the other side
Flip it, because this cuts both ways and the second edge is sharper than people expect.
If you defend an environment
A local model is not a private one in any sense that matters forensically. It does not phone home, which is the fear everyone actually has, and it writes an unusually candid record to local disk, which is the risk nobody budgeted for. If your data-classification policy covers documents and chat messages but not prompt histories, it has a hole in it the size of your engineering team.
Concretely: prompt histories should be in scope for disk encryption, for endpoint backup exclusions, and for offboarding wipes. Most of the time they are in none of the three.
If you run an insider-risk programme
This is the highest-signal artifact you are currently not collecting. It is also exactly the kind of monitoring that needs written policy and legal review before you touch it, because the same file that proves exfiltration also contains somebody's half-finished questions about a medical diagnosis, a divorce, or a job application. Collect it deliberately, with notice and a retention limit, or do not collect it at all. There is no defensible middle.
If you just use these tools
Assume the transcript is permanent and discoverable. Do not paste production credentials into a local model to save thirty seconds; rotate anything you already have. If your workflow genuinely requires sensitive context, find out whether your tooling supports disabling history, and verify the setting rather than trusting it:
# verify, do not assume
ls -la ~/.ollama/history 2>/dev/null && echo "history is being written"
stat -c '%y %n' ~/.ollama/history 2>/dev/nullInvestigators spent two decades learning to reconstruct intent from fragments. The tooling now writes it down in full sentences. Whether that is a gift or a liability depends entirely on which side of the disk image you are standing on.