🔄 Topic

A baseline for the whole agent stack: every change attributable to the agent and task that made it, and every change reversible through a documented recovery path.

🎯 Goal

Be able to answer two questions about anything on this machine: “who made this change, under which task?” and “how do I put it back?” — without archaeology.

🛠 What I Did

I made provenance and recovery a stated baseline instead of an accident of git.

Main areas covered:

  • established the provenance rule: every agent-produced change carries its task id, agent identity, and timestamp
  • audited existing artifacts against that rule and filled the attribution gaps
  • documented per-area recovery paths: how to roll back a code change, a doc reconcile, a config edit, and a model routing change
  • used git isolation so rollback of one task’s work does not drag unrelated changes with it
  • tied rollback docs to the permissions model: what an agent may change is bounded by what can be recovered
  • tested a real rollback instead of trusting the writeup

🔗 Key Cybersecurity Connections

Provenance is the forensic question — incident response starts with “what changed, when, by what.” A system where agents modify things without attribution is a system where investigation is guesswork.

Recovery is the resilience question. And the coupling matters: granting an agent write access to something unrecoverable is a different decision than granting access to something with a tested rollback. Permissions should follow recoverability.

🔍 Investigation Questions

  • Can every recent change be traced to a task and an agent?
  • Which writable areas have no tested recovery path?
  • Does rolling back one task’s change disturb anything else?
  • How long does attribution take — seconds, or an afternoon?
  • Is there anything agents can touch that backups do not cover?

🚨 Detection Opportunities

Checks for a provenance baseline:

  • change present with no task attribution
  • writable area missing from the recovery documentation
  • rollback rehearsal failing or never performed
  • attribution metadata diverging from git history
  • agent write into an area classified unrecoverable

Example:

project=provenance-baseline
signal=unattributed_change_in_agent_area
risk_area=untraceable_modification
triage=match_change_to_task_log_or_treat_as_incident

🧭 MITRE ATT&CK Techniques

Possible mappings for what this baseline defends against:

  • T1565 — Data Manipulation
  • T1070 — Indicator Removal

Attribution and tested recovery are the counters to both.

🗺 Visual Investigation Diagram

Change appears
    ↓
Attribution: task id + agent + time
    ↓
Scope: what else did this task touch?
    ↓
Decision: keep or roll back
    ↓
Recovery path, already documented and tested
    ↓
State restored, record kept

⚠ Challenges

The audit was humbling: plenty of older artifacts had no attribution at all. Backfilling taught me why provenance has to be automatic at write time — nobody reconstructs it accurately later.

📚 What I Learned

I learned that a recovery document is a hypothesis until it has been executed once. The tested rollback found a missing step the writeup was confident about.

➡ Next Steps

  • Enforce attribution at write time in every agent lane
  • Rehearse one recovery path per week until all are proven
  • Align the permissions model with recoverability classes
  • Alert on unattributed changes in agent-writable areas

🧠 Reflection

This closed a loop the whole stack depends on: autonomy is only safe when every action is attributable and reversible. It is the difference between an agent making changes and an agent leaving evidence.

🧩 Lessons Learned

What worked

Stating provenance and recovery as a baseline, then auditing against it.

What broke

Older artifacts had no attribution, and one rollback doc missed a step.

Why it broke

Both were written as good intentions, not enforced or rehearsed mechanics.

Fix / takeaway

Attribution at write time, rollbacks rehearsed for real, permissions bounded by recoverability.

📈 Skill Progression Context

This supports my cybersecurity progression because attribution, timeline reconstruction, and tested recovery are the exact mechanics of incident response and change control in any environment.

😄 TL;DR

Every agent change now signs its work and comes with a rehearsed undo.