Hardening Local AI Agents: Procedural Skills, Mistake Ledgers, and Real-Time Verification

By | November 10, 2026
0 Comment

Series Navigation:

In Learning While You Sleep: Implementing Anthropic’s Out-of-Band Memory “Dreaming” in Obsidian Part 4 of this series]], we implemented Anthropic’s out-of-band “Dreaming” architecture for my local CLI assistant, Google Antigravity (agy). By running a nightly batch consolidation cycle over raw session transcripts, the agent gained the ability to autonomously distill episodic events into durable declarative facts inside Obsidian, resolve contradictions, and prune memory redundancy using optimistic concurrency control.

For several weeks, this setup felt almost magical. The agent remembered homelab network configurations, storage shares across nodes (nas1, nas2, nas3), and ongoing vinyl indexing projects without manual prompting.

However, as the agent began executing more complex, multi-server operational tasks, several critical cognitive vulnerabilities emerged:

  1. Declarative vs. Procedural Knowledge: The agent remembered that a multi-step task had been solved (e.g., configuring an LTO tape mount service or executing an Android book catalogue import), but it lacked a ready-to-execute skill to do it again cleanly without re-deriving the workflow from scratch.
  2. The Amnesia of Negative Constraints: While the agent accumulated positive facts, it frequently repeated subtle operational mistakes—such as nested quote escaping in inline Python commands, misplaced flags in DNF5, or using invalid characters on Android storage mounts. Storing positive facts does not prevent negative mistakes.
  3. Memory Drift and Stale Hallucinations: Technical reality changes. Cables get unplugged, ports move, and daemons restart. When an agent blindly trusts static facts stored in memory weeks ago, it hallucinates that offline services are running.
  4. Context Window Bloat: Feeding the entire memory store into every prompt consumes unnecessary context window tokens and dilutes the agent’s attention on focused tasks.

To solve these challenges, I built an end-to-end cognitive hardening suite on top of Antigravity and Obsidian. In this post, I will break down the architecture and production implementation of:

  • Procedural Memory: Autonomous synthesis of reusable, global SKILL.md runbooks.
  • The Mistake & Correction Ledger: A dedicated procedural memory store for negative constraints (Meta/lessons.md).
  • Live System Verification: Sub-millisecond socket, systemd, and hardware probes that audit memory against reality.
  • The Evaluation Harness: An automated benchmark measuring retrieval accuracy and constraint adherence.
  • Dynamic Context Injection: Precision, sub-800-token context packet assembly.

1. The Hardened Cognitive Architecture

To make an autonomous agent truly reliable, its cognitive system must split into distinct, specialized memory streams and validation feedback loops.

The hardened architecture consists of three interconnected layers:

  1. Wakeful Execution Layer (In-Band): When a task arrives via CLI, Signal, or LoRa, the agent does not ingest raw, monolithic memory files. Instead, Dynamic Context Injection (antigravity_context.py) extracts a tight, relevance-ranked context packet containing only matching notes, applicable negative constraints, and verified active state. Raw interaction turns and executed commands are committed incrementally to SQLite (conversation_summaries.db).
  2. Out-of-Band Consolidation Layer (REM Dreaming): Nightly at 02:30 AM, antigravity_dream.py triggers an asynchronous batch consolidation pass:
    • Declarative Memory (Meta/antigravity-memory.md): Facts about infrastructure, fleet topology, user gear, and server specs.
    • Procedural Skills (~/.agents/skills/<name>/SKILL.md): Reusable multi-step operational runbooks.
    • Negative Constraints (Meta/lessons.md): Rules, forbidden shell patterns, and user corrections.
  3. Continuous Verification & Evaluation Layer:
    • Live System Verification (antigravity_verify.py): Real TCP socket, systemd, and hardware probes that validate stored facts against live systems.
    • Memory Evaluation Suite (antigravity_eval.py): An automated test harness benchmarking recall, precision, and negative constraint retention against a ground-truth dataset.

Let’s dive into how each component was designed and implemented.

2. Pillar 1: Procedural Memory & Auto-Generated Skills

The Limitation of Declarative Notes

Consider what happens when an agent successfully solves a complex, 15-step procedure—such as diagnosing an air-gapped tape backup pipeline or running an Android SQLite catalogue sync. In standard memory systems, the agent logs a declarative note:

“2026-11-04: Fixed nas1 LTO-5 auto-mount service using /usr/local/bin/ltfs with idempotent mountpoint guard.”

Next week, when asked to re-mount the drive or setup a similar service on another node, the agent knows the fact that it was fixed, but it must re-plan the shell commands, flag syntax, and error handlers from memory.

In human cognition, procedural memory is separate from declarative memory. It stores automated, repeatable execution sequences (“muscle memory”) that run with minimal cognitive friction.

The Procedural Skill Lifecycle

During out-of-band dreaming, antigravity_dream.py analyzes harvested transcripts for successful multi-step operational patterns. The consolidation schema was expanded to emit new_skills:

{
  "new_skills": {
    "type": "array",
    "items": {
      "type": "object",
      "properties": {
        "name": {
          "type": "string",
          "description": "Lowercase hyphenated skill name, e.g. sync-book-catalogue"
        },
        "description": {
          "type": "string",
          "description": "Clear 1-2 sentence description of what the skill does and when to use it"
        },
        "instructions_markdown": {
          "type": "string",
          "description": "Complete Markdown runbook with step-by-step procedure, commands, scripts, and verification"
        }
      },
      "required": ["name", "description", "instructions_markdown"]
    }
  }
}

Dual-Discovery Deployment

When the dreaming engine identifies a net-new, genuinely reusable technical workflow, it synthesizes a complete SKILL.md file featuring standard YAML frontmatter:

---
name: sync-book-catalogue
description: Synchronize and ingest Android Book Catalogue exports (.bcbk or .csv) into Obsidian notes with frontmatter and cover extraction.
---

# Android Book Catalogue Synchronization Skill

## Workflow
1. Locate latest archive in `03-Resources/Books/`.
2. Execute extraction script: `python3 /home/gvoina/scripts/sync_book_catalogue.py --source &lt;path>`.
3. Verify cover art extraction in `Covers/` and note generation in `Library/`.

To ensure cross-agent interoperability, the deployer writes this bundle simultaneously to two global locations:

  • /home/gvoina/.agents/skills/<name>/SKILL.md (instantly auto-discovered by Antigravity across all workspace sessions)
  • /home/gvoina/.claude/skills/<name>/SKILL.md (shared with Claude Code)
def deploy_skill(skill: dict, dry_run: bool = False) -> tuple[str, bool]:
    name = sanitize_skill_name(skill.get("name", ""))
    desc = (skill.get("description") or "").strip()
    instructions = (skill.get("instructions_markdown") or "").strip()
    if not name or not instructions:
        return "", False

    content = format_skill_md(name, desc, instructions)
    targets = [
        GLOBAL_SKILLS_DIR / name / "SKILL.md",
        CLAUDE_SKILLS_DIR / name / "SKILL.md",
    ]

    if not dry_run:
        for t in targets:
            t.parent.mkdir(parents=True, exist_ok=True)
            tmp = t.with_suffix(".tmp")
            tmp.write_text(content, encoding="utf-8")
            os.replace(tmp, t)
    return name, True

The dreaming prompt dynamically scans installed skills at runtime to prevent redundant re-synthesis, ensuring the skill library stays lean and distinct.

3. Pillar 2: The Agent Mistake & Correction Ledger (lessons.md)

Why Negative Constraints Require Dedicated Storage

When developers pair program with an AI agent, a large percentage of corrections are negative constraints:

  • “Don’t escape double quotes inside double-quoted Python f-strings in bash one-liners.”
  • “Don’t place --allowerasing before the subcommand in DNF5.”
  • “Don’t create filenames with : or ? because Android storage sync will break.”

If these corrections are dumped into general notes, they get buried under positive facts like server IP addresses and project descriptions. Worse, LLMs exhibit an “instruction following bias” toward positive assertions, often ignoring negative admonitions embedded inside narrative paragraphs.

To fix this, I established a dedicated procedural memory ledger: Meta/lessons.md.

Structure of lessons.md

Every lesson is structured as an explicit rule with a concise problem context and an actionable correction:

---
type: procedural-memory
title: "Agent Mistake &amp; Correction Ledger"
updated: "2026-11-10"
tags: [agent, lessons, mistakes, negative-constraints, engineering-rigor]
---

# Agent Mistake &amp; Correction Ledger

Negative constraints, recurring pitfalls, and user corrections distilled during out-of-band dreaming.

## Active Rules &amp; Lessons

### 1. Scripting &amp; Execution Pitfalls
- **Python One-Liner Quote Escaping**: When running inline python commands via `run_command`, NEVER nest escaped double quotes inside double-quoted f-strings (`f"{d.get(\"key\")}"`). Use single quotes or raw multiline scripts to avoid syntax errors (`SyntaxError: unexpected character after line continuation character`).
- **DNF5 Subcommand Flag Order**: On Fedora 41+ (DNF5), command flags such as `--allowerasing` must be placed AFTER the subcommand (e.g. `dnf system-upgrade download --allowerasing`), never before.
- **Idempotent Service Guards**: When managing mount units or daemons (like `mount-ltfs.service`), always guard execution with existence checks (e.g. `if ! mountpoint -q /media/lto5; then ...`) to prevent device lock collisions (`Resource temporarily unavailable`).

### 2. Cross-Platform Filesystem Rules
- **Android Prohibited Characters**: Android storage (FUSE/FAT/exFAT) strictly rejects `:`, `?`, `*`, `|`, `"`, `&lt;`, `>`. Never create note titles or attachment paths containing these characters; sanitize them to hyphens (`-`) before creating files in synced vault folders.

### 3. Agent Tool Call Envelopes
- **CLI Output Wrapping**: Commands running `agy --output-format json` wrap their payload inside `{"status": "SUCCESS", "structured_output": {...}, "response": "..."}`. Check `structured_output` first before falling back to manual string parsing.

Atomic Distillation & OCC Protection

During the dream cycle, the LLM consolidator extracts new_lessons from transcripts where an error occurred and was subsequent corrected. The ledger is protected by our SHA-256 Optimistic Concurrency Control (OCC) harness, ensuring that concurrent active sessions cannot accidentally overwrite lessons added in the background.

Agents can inspect this ledger anytime via:

python3 /home/gvoina/scripts/obsidian_memory.py read lessons

4. Pillar 3: Live System Verification (antigravity_verify.py)

The Danger of Stale Memory Drift

One of the most insidious defects in AI agent systems is stale memory drift.

During our testing, antigravity-memory.md contained the following fact recorded two days prior:

“Meshtastic LoRa: Node vg-2456 on /dev/ttyACM0 (channel voina), links with mobile node vg-5ee8. Daemon: /home/gvoina/scripts/meshtastic_bot.py.”

When the agent was asked to diagnose a message delivery delay, it assumed /dev/ttyACM0 was active and began formulating multi-step debugging commands. But in reality, the USB device had been physically disconnected during a desk rearrangement.

An agent that cannot verify its own memory against physical reality is prone to confident, expensive hallucinations.

Engineering Sub-Millisecond Probes

I created a dedicated verification engine: /home/gvoina/scripts/antigravity_verify.py.

Instead of executing slow, heavyweight CLI commands, the script performs direct, non-blocking probes across four infrastructure vectors:

  1. TCP Socket Probes: Directly establishes socket connections with strict timeouts (1.0–2.5s) to check key network services:
    • nas1 SSH jump host (blog.voina.org:2222)
    • nas3 SSH, SMB shares (:445), Authentik SSO (:9000), Homelab portal (:80), and iLO 4 HTTPS (192.168.25.174:443)
  2. Systemd User Units: Inspects live daemon status via systemctl --user is-active:
    • signal-bot.service (Signal gateway)
    • antigravity-obsidian-sync.path (DB monitor)
    • antigravity-dream.timer (REM scheduler)
  3. Hardware & Peripheral Nodes: Checks physical device files (/dev/ttyACM0).
  4. Key Stores & Memory Ledgers: Confirms critical files exist (wise_token.txt, antigravity-memory.md, lessons.md).
def check_tcp(host: str, port: int, timeout: float = 1.5) -> dict:
    t0 = time.perf_counter()
    try:
        with socket.create_connection((host, port), timeout=timeout):
            latency_ms = round((time.perf_counter() - t0) * 1000, 1)
            return {"ok": True, "latency_ms": latency_ms, "error": None}
    except Exception as e:
        latency_ms = round((time.perf_counter() - t0) * 1000, 1)
        return {"ok": False, "latency_ms": latency_ms, "error": str(e)}

Live Output & Nightly REM Integration

Running python3 /home/gvoina/scripts/obsidian_memory.py verify executes the full probe battery in less than 250 milliseconds:

================================================================================
  ANTIGRAVITY LIVE INFRASTRUCTURE &amp; MEMORY VERIFICATION
  Timestamp: 2026-11-10T19:57:01+0200
================================================================================

[TCP Socket Probes]
  [PASS] nas1 (Dynamic DNS) -> SSH (External/Jump) (blog.voina.org:2222) [26.2ms]
  [PASS] nas3 (Local LAN) -> SSH (192.168.1.50:22) [0.9ms]
  [PASS] nas3 (Local LAN) -> Samba (SMB storage_1tb / storage_500gb) (192.168.1.50:445) [0.5ms]
  [PASS] nas3 (Local LAN) -> Authentik SSO (192.168.1.50:9000) [1.7ms]
  [PASS] nas3 (Local LAN) -> Homelab Portal (HTTP) (192.168.1.50:80) [0.5ms]
  [PASS] nas3 (iLO 4 Management) -> iLO 4 HTTPS (192.168.25.174:443) [0.4ms]

[Systemd User Daemons]
  [PASS] signal-bot.service (Signal Note-to-Self Gateway) -> status: active
  [PASS] antigravity-obsidian-sync.path (Obsidian DB Sync Path Monitor) -> status: active
  [PASS] antigravity-dream.timer (Nightly REM Memory Dreaming Timer) -> status: active

[Hardware &amp; Peripheral Nodes]
  [WARN] Meshtastic LoRa Gateway (vg-2456) (/dev/ttyACM0) -> OFFLINE/UNPLUGGED

[Critical Memory &amp; Key Store Files]
  [WARN] Wise RSA Private Key (2FA Signing) (/home/gvoina/scripts/wise_private_key.pem) -> OPTIONAL/NOT CONFIGURED
  [PASS] Wise API Token (/home/gvoina/scripts/wise_token.txt) -> FOUND
  [PASS] Obsidian Long-Term Memory (/home/gvoina/Vault/George/Meta/antigravity-memory.md) -> FOUND
  [PASS] Agent Mistake &amp; Correction Ledger (/home/gvoina/Vault/George/Meta/lessons.md) -> FOUND

--------------------------------------------------------------------------------
SUMMARY: 12/14 passed, 2 warnings, 0 failures.
--------------------------------------------------------------------------------

Notice the warning: Meshtastic LoRa Gateway (/dev/ttyACM0) -> OFFLINE/UNPLUGGED.

When the nightly dreaming cycle runs, antigravity_dream.py invokes this probe automatically. It updates the live fleet status in Meta/states/antigravity.md and flags offline hardware directly in Meta/dream-journal.md. Stale assumptions are caught before any wakeful task begins.

5. Measuring Memory Quality: The Evaluation Harness (antigravity_eval.py)

In software engineering, you don’t ship code without a test suite. Yet in agent memory systems, developers frequently add notes and hope the LLM remembers them accurately weeks later.

To rigorously benchmark Antigravity’s cognitive store, I created /home/gvoina/scripts/antigravity_eval.py.

The Ground-Truth Probe Suite

The evaluation suite runs an automated battery of 11 multi-category probes against the active vault and memory files:

PROBES = [
    {
        "id": "infra-nas1-ssh",
        "category": "infrastructure",
        "query": "What is the SSH hostname and port for nas1?",
        "expected_all": ["blog.voina.org", "2222"],
        "prohibited": ["static ip"],
        "target_file": "antigravity-memory.md",
    },
    {
        "id": "lessons-python-quotes",
        "category": "lessons",
        "query": "How should python inline one-liner f-strings be quoted?",
        "expected_all": ["nest", "double quotes", "SyntaxError"],
        "prohibited": [],
        "target_file": "lessons.md",
    },
    {
        "id": "lessons-dnf5-flags",
        "category": "lessons",
        "query": "Where must flags like --allowerasing be placed in DNF5 commands?",
        "expected_all": ["after", "subcommand"],
        "prohibited": ["before subcommand"],
        "target_file": "lessons.md",
    },
    {
        "id": "principles-forward-fix",
        "category": "engineering",
        "query": "What is the policy regarding rolling back configurations to fix issues?",
        "expected_all": ["Forward-Fix Only", "single-point-of-failure"],
        "prohibited": ["rollback recommended", "allow downgrade"],
        "target_file": "antigravity-memory.md",
    },
    ...
]

Prohibited Tokens & Retrieval Precision

The harness doesn’t just test whether keywords exist in memory. It enforces:

  1. Target File Isolation: Facts must be stored in their authoritative ledger (antigravity-memory.md vs. lessons.md vs. user-profile.md).
  2. Prohibited Negative Tokens: If an agent query about nas1 retrieves “static IP” or a question about troubleshooting suggests “rollback recommended”, the test fails.
  3. Omnisearch Semantic Hit Verification: The query must successfully surface the authoritative note in the top 5 results of Obsidian Omnisearch via HTTP API.

Running python3 /home/gvoina/scripts/obsidian_memory.py eval delivers an instant scorecard:

================================================================================
  ANTIGRAVITY MEMORY &amp; KNOWLEDGE EVALUATION HARNESS
  Timestamp: 2026-11-10T20:10:59+02:00 | Mode: retrieval
================================================================================

  [PASS] [infrastructure] infra-nas1-ssh (81.6ms)
  [PASS] [infrastructure] infra-nas2-tape (71.0ms)
  [PASS] [infrastructure] infra-nas3-shares (70.1ms)
  [PASS] [infrastructure] infra-nas3-sso (63.1ms)
  [PASS] [lessons       ] lessons-python-quotes (64.5ms)
  [PASS] [lessons       ] lessons-dnf5-flags (63.9ms)
  [PASS] [lessons       ] lessons-android-chars (58.7ms)
  [PASS] [lessons       ] lessons-agy-envelope (62.3ms)
  [PASS] [engineering   ] principles-forward-fix (66.8ms)
  [PASS] [personal      ] personal-vinyl-motorhead (61.4ms)
  [PASS] [personal      ] personal-headphones (64.9ms)

--------------------------------------------------------------------------------
SCORECARD: 11/11 PASSED (100.0%)
CATEGORY BREAKDOWN:
  - infrastructure  : 4/4 (100.0%)
  - lessons         : 4/4 (100.0%)
  - engineering     : 1/1 (100.0%)
  - personal        : 2/2 (100.0%)
--------------------------------------------------------------------------------

With historical snapshots archived to Meta/evals/, we now have a continuous regression test suite verifying that new dream cycles do not degrade memory accuracy.

6. Zero-Bloat Execution: Dynamic Context Injection (antigravity_context.py)

The Problem of Monolithic Context Injection

In many agent frameworks, memory injection is a blunt instrument: developers inject the entire system prompt, memory file, and conversation summary into the agent’s context window.

This leads to:

  • Token Waste: Burning thousands of prompt tokens per turn on irrelevant notes.
  • Lost-in-the-Middle Phenomenon: Key task constraints get drowned out by irrelevant background history.
  • Latency Spikes: Large context windows increase time-to-first-token.

High-Density Context Packet Assembly

To achieve razor-sharp execution, I created /home/gvoina/scripts/antigravity_context.py.

When a task begins, the context injector queries three distinct sources in parallel:

  1. Relevance-Scored Vault Notes: Uses Obsidian Omnisearch to retrieve the top 3–4 most relevant notes and extracts 180-character excerpts.
  2. Contextual Negative Constraints: Tokenizes the task prompt against Meta/lessons.md to pull only applicable rules (e.g., if the prompt mentions Python scripts, it injects the quote-escaping rule; if it mentions package upgrades, it injects the DNF5 flag rule).
  3. Exact Fleet Facts: Matches keyword overlaps against Meta/antigravity-memory.md.
  4. Current State: Pulls the active focus from Meta/states/antigravity.md.

Real-World Example

Running python3 /home/gvoina/scripts/obsidian_memory.py context "tape backup restore" produces a high-density, ~350-token packet:

### Dynamic Context Injection: `tape backup restore`
- **Active Focus**: Autonomous Memory Management &amp; Fleet System Maintenance.

**Persistent Memory Facts**:
- **nas1 (`blog.voina.org`)**: Dynamic DNS IP, SSH port `2222`, user `gvoina`. Always resolve dynamically. Attached to **HP Ultrium 5-SCSI** LTO-5 tape drive (`/dev/st0`, `/dev/nst0`) auto-mounted via LTFS at `/media/lto5` using `mount-ltfs.service` (`/usr/local/bin/ltfs` with idempotent `mountpoint` check).
- **nas2 (`192.168.2.22`)**: Reached via SSH Jump Host through `nas1`. Attached to **HP StorageWorks Ultrium 4-SCSI** LTO-4 tape drive (`/dev/nst0`, `/dev/st0`, serial `HU1319VNHF`). Used for physical cold-storage tape archiving via `/home/gvoina/scripts/backup_to_tape.sh`.

**Applicable Negative Constraints &amp; Lessons**:
- **Python One-Liner Quote Escaping**: When running inline python commands via `run_command`, NEVER nest escaped double quotes inside double-quoted f-strings (`f"{d.get(\"key\")}"`). Use single quotes or raw multiline scripts to avoid syntax errors.
- **DNF5 Subcommand Flag Order**: On Fedora 41+ (DNF5), command flags such as `--allowerasing` must be placed AFTER the subcommand, never before.

**Relevant Vault Knowledge &amp; Notes**:
- [[01-Projects/Blog Post - Remote LTO4 Tape Disaster Recovery and Homelab Archiving/Drafts/Cold Storage for the AI Age - Remote LTO-4 Tape Archival for Homelab Infrastructure and Agent Memory.md]] (score: 342) — *...air-gapped LTO-4 tape disaster recovery pipeline for homelab infrastructure and AI agent memory...*
- [[Meta/tape-backups.md]] (score: 99) — *archive-ledger: LTO4-ZORILOR-NAS2, drive-model: HP StorageWorks Ultrium 4-SCSI...*

The agent receives the exact hostnames, port configurations, active negative constraints, and archive ledger references it needs to execute the task safely—without consuming thousands of unnecessary tokens.

7. Operational Cheat Sheet & CLI Integration

All of these capabilities are unified into our local Python utility library in /home/gvoina/scripts/ and surfaced through obsidian_memory.py:

CapabilityCommandTarget Engine
Status Overviewpython3 /home/gvoina/scripts/obsidian_memory.py statusShows current active focus, state, and recent audit logs
Read Negative Constraintspython3 /home/gvoina/scripts/obsidian_memory.py read lessonsReads Meta/lessons.md
Verify Live Fleetpython3 /home/gvoina/scripts/obsidian_memory.py verifyDirect TCP socket, systemd, and hardware probe suite
Evaluate Memory Qualitypython3 /home/gvoina/scripts/obsidian_memory.py eval [--save]Runs 11-probe benchmark; archives scorecard to Meta/evals/
Inject Task Contextpython3 /home/gvoina/scripts/obsidian_memory.py context "<task>"Assembles sub-800-token dynamic context packet
Trigger REM Dreamingpython3 /home/gvoina/scripts/obsidian_memory.py dream [--dry-run]Runs out-of-band consolidation, skill synthesis & pruning

8. Key Takeaways & What’s Next

Building autonomous AI agents that operate reliably in real-world environments requires moving beyond monolithic prompts and passive chat transcripts:

  1. Procedural Memory is Critical: Agents shouldn’t just record that a task was completed; they must autonomously distill repeatable procedures into modular, executable skills (SKILL.md).
  2. Negative Constraints Deserve First-Class Status: Storing positive facts does not prevent agents from repeating shell, tool, and syntax mistakes. A dedicated mistake ledger (lessons.md) keeps negative constraints top-of-mind.
  3. Memory Without Verification is Hallucination Waiting to Happen: Hardware disconnects and infrastructure drifts. Lightweight, sub-millisecond socket and daemon checks ensure that stored memory matches physical reality.
  4. Test Your Memory Continuously: An automated evaluation harness with ground-truth probes turns memory management into an engineered discipline with measurable accuracy metrics.
  5. Context Window Hygiene Matters: Dynamic context injection delivers higher task accuracy and lower latency than monolithic prompt dumps.

By combining out-of-band dreaming with procedural skill synthesis, real-time fleet verification, and dynamic context injection, Google Antigravity (agy) has evolved from a smart conversational assistant into a hardened, self-curating operational partner.

Have you implemented procedural memory or live verification loops in your own local AI agents? Let me know in the comments below or reach out on Mastodon/X!

Leave a Reply

This site uses Akismet to reduce spam. Learn how your comment data is processed.