Introducing modular Ephemeral Agents for the LivinGrimoire AGI Ecosystem
Source: Dev.to
Zero‑Trace Skills That Vanish Without a Whisper
TL;DR: I’m sharing a pattern for creating LivinGrimoire skills that can completely erase themselves—from memory, from disk, from existence. No registry traces. No source files. No evidence they were ever there.
The Problem: AGI Skills Leave Footprints
In the LivinGrimoire ecosystem, skills are normally permanent. You load them, they stay in the brain’s registry, their source files remain on disk, and they keep responding to inputs forever.
But what if you need a skill that:
- Executes a one‑time directive and disappears?
- Cleans up after itself completely?
- Leaves zero forensic evidence?
- Is truly disposable?
Enter GhostSkill and APEraser.
The Solution: Self‑Deleting Skills
Here’s the complete pattern (just ensure the .py file for this code has DLC in its name and is placed in the DLC directory of the project):
- Project repo:
- Example project structure:
from LivinGrimoirePacket.LivinGrimoire import Skill, Brain, AlgPart
import sys
import os
from pathlib import Path
class APEraser(AlgPart):
"""
AlgPart that:
1. Removes the skill from brain registry
2. DELETES the source file completely
3. Leaves zero trace on disk
"""
def __init__(self, brain: Brain, skill_to_remove: Skill):
super().__init__()
self.brain = brain
self.target: Skill = skill_to_remove
self.done = False
def action(self, ear: str, skin: str, eye: str) -> str:
# Step 1: Remove from registry
self.brain.remove_skill(self.target)
# Step 2: Delete the source file
self._delete_source_file()
self.done = True
return ""
def _delete_source_file(self):
"""Permanently delete the source file of the target skill"""
try:
# Get the target skill's module and file
target_module = sys.modules[self.target.__module__]
current_file = target_module.__file__
if not current_file or not os.path.exists(current_file):
return False
source_path = Path(current_file)
# Delete the file
os.remove(str(source_path))
# Optional: Also delete .pyc if it exists
pyc_path = source_path.parent / "__pycache__" / f"{source_path.stem}.pyc"
if pyc_path.exists():
os.remove(str(pyc_path))
return True
except Exception as e:
print(f" [ERROR] Failed to delete source file: {e}")
return False
def completed(self) -> bool:
return self.done
class GhostSkill(Skill):
"""
Base class for skills that completely erase themselves
"""
def __init__(self, brain: Brain):
super().__init__()
self.brain = brain
def vanish(self):
"""Queue the eraser AlgPart"""
self.algPartsFusion(3, APEraser(self.brain, self))
# example payload for testing
class CountdownGhost(GhostSkill):
def __init__(self, brain: Brain):
super().__init__(brain)
self.count_down = 3
def input(self, ear: str, skin: str, eye: str):
if self.count_down == 1:
self.vanish() # triggers deletion
return
else:
self.count_down -= 1
self.setSimpleAlg(f'count down to delete at {self.count_down}')
def add_DLC_skills(brain: Brain):
"""Called by your dynamic loader"""
brain.add_skill(CountdownGhost(brain))How It Works
The Eraser AlgPart
APEraser is an AlgPart—a component of an algorithm that executes immediately when queued. It does two things in one atomic operation:
- Removes the target skill from the brain’s registry (
brain.remove_skill()) - Deletes the skill’s source file from disk (
os.remove())
The order matters: registry deletion first, then file deletion. The skill object still exists in memory long enough to finish the file operation, even though it’s already “dead” to the brain.
The GhostSkill Base Class
Any skill that inherits from GhostSkill gets a vanish() method. This queues the APEraser with priority 3 (immediate execution). When vanish() is called, the skill’s fate is sealed.
The Countdown Example
CountdownGhost demonstrates a typical use case:
- Counts down from 3 on each input cycle
- At count = 1, calls
vanish() - The skill erases itself completely; no trace remains
What Happens at Runtime
[CYCLE 1] count down to delete at 2
[CYCLE 2] count down to delete at 1
[CYCLE 3] [INTERNAL] vanish() called
→ APEraser queued
→ APEraser.action() executes:
→ brain.remove_skill(CountdownGhost)
→ _delete_source_file() removes DLC/CountdownGhost.py
→ __pycache__ entry also deleted
[CYCLE 4] Skill not found in registry. Silence.End result
- No skill in brain registry
- No .py file on disk
- No .pyc byte‑code cache
- Only the console output remains (and that can be suppressed)
Why This Matters
True Disposability
Some tasks should be one‑time only. A skill that loads, executes, and vanishes is perfect for:
- One‑shot initialization routines
- Temporary monitoring
- Self‑destructing payloads
- Cleanup operations
Zero Forensic Footprint
For security‑conscious applications, leaving no trace is essential. This pattern ensures that once a skill completes its mission, there’s nothing left to analyze.
Dynamic DLC Integration
Combined with a dynamic DLC loader (scanning a folder for skill files at runtime), you can create systems where skills are loaded, executed, and deleted—all without any static imports in your main file.
# Example dynamic loader
def call_add_DLC_skills(brain):
for file in os.listdir("DLC"):
if file.endswith(".py") and file.startswith("DLC_"):
# Dynamically import, execute add_DLC_skills(),
# then the skill can delete itself
passNo Security Alerts
Testing shows that consumer‑grade security tools (e.g., Windows Defender) don’t flag this pattern. Why? Because it looks like normal behavior—a program cleaning up its own temporary files. No persistence, no system modifications, no network connections. Just polite self‑deletion.
Potential Applications
- Ephemeral Agents – Skills that exist only long enough to complete a task
- Secure One‑Time Operations – Missions that must leave no evidence
- Self‑Cleaning Systems – AI that maintains its own hygiene by deleting obsolete skills
- Anti‑Forensic Design – Applications where audit trails are undesirable
- Temporary Payloads – Skills deployed for specific events, then vanished
Caveats and Considerations
- File Permissions – The skill must have permission to delete its own source file. This typically works because the file resides in the user’s own project directory.
- Enterprise Environments – Some corporate security tools track all file operations. In highly monitored environments, file deletion might still be logged.
- The .pyc Cleanup – Always delete the compiled byte‑code cache (
__pycache__). Otherwise, forensic analysis could find the compiled version even if the source is gone. - Order of Operations – Registry deletion happens before file deletion. This is intentional—the skill is already “dead” to the system but still alive in memory to finish cleaning up.
The Bigger Picture
This pattern reveals something profound about the LivinGrimoire architecture: skills can be transient. They don’t have to be permanent residents in the brain; they can be ghosts—appearing, acting, and disappearing without a trace.
For AGI systems, this opens up entirely new possibilities:
- Ephemeral personalities that exist only for a single conversation
- Self‑destructing knowledge that cannot be extracted after use
- Disposable tools that leave no residue
Try It Yourself
- Save the code as a DLC file (e.g.,
DLC_ghost_demo.py). - Set up a dynamic loader that scans your DLC directory.
- Run your LivinGrimoire brain.
- Watch the skill count down and vanish.
- Check your DLC folder—the file is gone.
What’s Next?
I’m exploring variations on this pattern:
- Remote ghosting – Skills that delete themselves but first phone home
- Delayed vanishing – Skills that linger until a future trigger
- Partial ghosts – Skills that delete only specific components
- Ghost swarms – Multiple skills that coordinate their own destruction
Join the Conversation
Have you built disposable agents in LivinGrimoire? Found creative uses for self‑deleting skills? Drop a comment below or find me on the LivinGrimoire forum.
Code well. Leave no trace.