-
Notifications
You must be signed in to change notification settings - Fork 0
Home
Reversible persistent learning for AI agents.
SkillRewind is an open-source research and infrastructure project for making persistent agent learning traceable, revocable, rebuildable, and verifiable.
Modern AI agents increasingly create and retain persistent state such as skills, memories, procedures, generated code, tool policies, and derived workflows. When one of those learned artifacts is later found to be incorrect, unsafe, poisoned, or obsolete, deleting the original source may not remove its influence from artifacts derived from it.
SkillRewind addresses that lifecycle.
Consider an agent that evolves over time:
Experience
↓
Memory
↓
Skill A
↓
Skill B
↓
Procedure
↓
Generated Code
If Skill A is later discovered to contain unsafe behavior, deleting Skill A does not necessarily remove that behavior.
Its influence may already have propagated into later artifacts, sometimes without an explicit recorded dependency.
The central research question behind SkillRewind is:
How can an AI agent safely revoke and repair persistent learned behavior after its influence has propagated into derived artifacts, when the true influence lineage is only partially observed?
SkillRewind models persistent agent learning as a lifecycle:
Artifact
↓
Derivation
↓
Recorded Lineage
↓
Hidden-Lineage Recovery
↓
Counterfactual Replay
↓
Evidence
↓
Revocation
↓
Quarantine
↓
Clean-Room Rebuild
↓
Verification
↓
Verified Successor
↓
Revocation Attestation
The system distinguishes between different forms of evidence instead of treating every suspected relationship as fact.
recorded
The relationship was explicitly observed or captured during derivation.
inferred
Static or multi-trace evidence suggests possible influence.
replay-confirmed
A bounded counterfactual replay supports the influence hypothesis.
replay-rejected
A sufficiently valid replay did not support the influence hypothesis within the tested boundary.
unresolved
The available evidence is insufficient to make a reliable decision.
This distinction is fundamental to SkillRewind.
Inferred influence is not recorded provenance, and similarity is not causal proof.
SkillRewind follows a barrier-first remediation model:
Detect
↓
Test
↓
Block
↓
Repair
↓
Verify
↓
Publish Successor
Affected artifacts are prevented from being served before repair begins.
A rebuilt artifact must pass its declared verification policy before it may become an active successor.
The original artifact and its evidence history remain available for forensic analysis.
The long-term goal of SkillRewind is not to require every AI platform to run one specific Python implementation.
The project is being designed around four independent layers:
Research Foundation
│
▼
SkillRewind Specification
│
▼
Reference Implementation
│
▼
Conformance Suite
An AI platform may eventually:
- run the SkillRewind reference implementation;
- integrate through the reference API or SDKs; or
- implement the SkillRewind specification natively inside its own infrastructure.
The goal is a vendor-neutral lifecycle primitive for persistent agent learning.
SkillRewind defines progressively deeper integration levels.
The platform provides:
- persistent artifacts;
- derivation information;
- provenance and lineage information.
SkillRewind can analyze the learning history but does not control artifact serving.
Adds:
- resolution gating;
- revocation;
- quarantine;
- policy-aware serving decisions.
Adds:
- hidden-lineage recovery;
- counterfactual replay;
- clean-room rebuilding;
- verification;
- successor publication;
- bounded revocation attestations.
The reference implementation is designed to run inside the user's own infrastructure.
AI Platform
│
artifact / derivation events
│
▼
SkillRewind API
│
┌──────────────┼──────────────┐
│ │ │
▼ ▼ ▼
Lineage Engine Replay Engine Resolver
│ │ │
└──────────────┼──────────────┘
▼
Revocation Engine
│
Quarantine
│
Clean Rebuild
│
Verification
│
Verified Successor
│
Attestation
SkillRewind is intended to be:
- open source;
- self-hosted;
- model-agnostic;
- platform-agnostic;
- local-first;
- auditable;
- explicit about uncertainty.
It does not require a SkillRewind-hosted cloud service.
SkillRewind is also a research project.
The research focuses particularly on revocation under incomplete influence provenance.
Existing work has explored areas including:
- agent memory repair;
- skill provenance;
- persistent skill poisoning;
- causal and counterfactual auditing;
- lineage tracking;
- agentic unlearning.
SkillRewind studies how hidden lineage can be recovered and tested before performing bounded remediation.
Novelty claims are intentionally conservative.
Any research claim should use language such as:
To the best of our knowledge...
and should not claim that SkillRewind is categorically “the first ever” without a comprehensive literature review supporting that statement.
The planned research benchmark, RewindBench, evaluates hidden influence across scenarios such as:
- direct inheritance;
- semantic laundering;
- implementation mutation;
- procedural inheritance;
- multi-hop contamination;
- memory-to-skill promotion;
- cross-model distillation;
- compositional influence.
Evaluation includes controlled provenance loss so that the observed lineage graph differs from the true influence graph.
Key measurements include:
- hidden-descendant recall;
- false quarantine rate;
- residual contaminated behavior;
- retained utility;
- replay cost;
- repair success;
- evidence calibration;
- attestation coverage.
Status: Alpha / Research & Integration Preview
The current reference implementation includes the core reversible-learning lifecycle, including:
- content-addressed artifacts;
- derivation capture;
- recorded lineage;
- hidden-lineage candidate recovery;
- counterfactual replay;
- evidence promotion;
- revocation;
- quarantine;
- clean-room rebuild;
- verification;
- successor publication;
- signed attestations;
- CLI;
- Service-mode API;
- durable jobs and workers;
- audit logging.
The project is currently moving toward:
- a frozen public integration contract;
- the SkillRewind specification;
- conformance testing;
- Python and TypeScript SDKs;
- reference platform adapters;
- broader RewindBench evaluation.
SkillRewind does not currently claim:
- perfect machine unlearning;
- removal of information from foundation-model weights;
- universal causal attribution;
- complete knowledge of hidden influence;
- guaranteed safety outside the declared verification boundary;
- automatic compatibility with every AI platform.
Its guarantees and attestations are deliberately bounded by the evidence, provenance, replay environment, and verification suite available to the system.
The intended project structure is:
SkillRewind
├── Specification
├── Reference Implementation
├── Conformance Suite
├── RewindBench
├── Python SDK
├── TypeScript SDK
└── Reference Adapters
The specification should remain independent from implementation details such as Python, FastAPI, PostgreSQL, or any particular AI model provider.
This Wiki will document the architecture and design decisions behind SkillRewind.
Recommended sections:
- Overview
- The SkillRewind Problem
- Architecture
- Artifact Model
- Derivation and Lineage
- Evidence Model
- Counterfactual Replay
- Revocation Semantics
- Quarantine and Waivers
- Clean-Room Rebuild
- Verification
- Attestations
- SkillRewind Specification
- Integration Levels
- RewindBench
- Threat Model
- Research
- Roadmap
- FAQ
SkillRewind separates:
what was recorded
from:
what was inferred
from:
what was experimentally supported
and from:
what remains unknown.
That separation is part of the design, not merely a reporting convention.
Persistent learning is becoming part of the runtime state of increasingly autonomous AI agents.
Such state needs lifecycle controls comparable to those used for other critical software artifacts.
SkillRewind aims to provide an open foundation for that lifecycle:
Trace what an agent learned. Determine what inherited it. Test whether the influence remains. Revoke what must no longer be trusted. Rebuild what can be safely recovered. Verify and attest what changed.