ASK KNOX
beta
Learn/The Seven Levels of Agent Orchestration/Lesson 331
LESSON 331

The Skill Curator: Beating Context Rot

Every skill you never delete is silently making your agent dumber — the Skill Curator is how you keep the library sharp as it grows.

6 min read·The Seven Levels of Agent Orchestration

Introduction

Here is a failure mode no one warns you about: your agent gets better over time as you add skills, and then it gets worse.

Not because the new skills are bad. Because the old ones never left.

Every skill in your agent's library takes up space in the context window. Space you pay for in tokens. Space that dilutes the model's attention across capabilities it may not have used in months. At some point, the skill library stops being an asset and starts being noise — and that noise makes the agent slower, more expensive, and less accurate.

This is . And the fix is a Skill Curator.

Core Concept

How Context Rot Happens

Self-improving agents generate skills based on patterns they observe. Every time you ask the agent to do something new, it might create a skill for it. That is a feature — but only if paired with a mechanism to remove skills that stop being useful.

Without curation, a skill library looks like this after 6 months:

  • 12 skills for research tasks you ran intensively in Q1, never since
  • 8 skills for a project that was cancelled
  • 5 near-duplicate skills created by slightly different prompts
  • 3 skills that reference APIs that have changed and will fail if called
  • 20 skills you actually use every week

When the agent loads context for an interaction, all 48 skills go in. The model has to parse all of them to decide which one applies. Your 20 active skills compete for attention against 28 irrelevant ones. Response quality drops. Cost goes up.

The token cost is real: at typical skill file sizes and current pricing, a bloated skill library can consume 15-25% of your context budget before you write a single message. Knox's own MEMORY.md (his agent's long-term memory file — a level-6 concept covered later in this track) hit 339 lines and started truncating — the same failure mode, different layer.

The Skill Lifecycle

The Agent Framework Curator defines three states for every skill:

Active — the skill has been invoked in the last 30 days. It stays in the library. No action needed.

Stale — the skill has not been invoked in 30+ days. It gets flagged with a stale_since timestamp. The agent surfaces it for review: "these skills haven't been used in 30 days — keep, archive, or delete?" The human decides. This is the grace period.

Archived/Deleted — the skill has not been invoked in 90+ days. It is removed from the active library. Depending on your configuration, it may be archived (saved to a cold store for potential reactivation) or deleted entirely.

Both thresholds are configurable. High-volume agents with rapidly changing work patterns might use 14-day/45-day cycles. Slower-moving agents might extend to 60-day/180-day cycles. The defaults (30/90) work well for most builders.

What to Track

To implement a Curator, your agent needs to track one piece of data per skill: the last-invoked timestamp. Every time a skill is executed, update last_invoked. On a scheduled cron (daily or weekly), run the Curator check:

from datetime import datetime, timedelta

STALE_THRESHOLD = timedelta(days=30)
DELETE_THRESHOLD = timedelta(days=90)

def curate_skills(skills: list[dict]) -> dict:
    now = datetime.utcnow()
    stale = []
    to_delete = []

    for skill in skills:
        last_invoked = skill.get("last_invoked")
        if last_invoked is None:
            # Never invoked — treat as stale from creation date
            last_invoked = skill["created_at"]

        age = now - datetime.fromisoformat(last_invoked)

        if age > DELETE_THRESHOLD:
            to_delete.append(skill["name"])
        elif age > STALE_THRESHOLD:
            stale.append(skill["name"])

    return {"stale": stale, "to_delete": to_delete}

The Curator runs this on schedule, generates a report, and sends it to your messaging platform: "5 skills are stale, 2 are past deletion threshold. Review here." You approve or override; the Curator executes.

Practical Application

Here is what a concrete Curator report looks like in Discord:

Agent Skill Audit — 2026-05-30

STALE (30+ days, 6 skills):
  - youtube_transcript_extractor (last used: 2026-04-12)
  - polymarket_odds_lookup (last used: 2026-04-01)
  - capcut_project_export (last used: 2026-03-28)
  ... and 3 more

DELETION CANDIDATE (90+ days, 2 skills):
  - elon_tweet_monitor (last used: 2026-02-10)
  - nft_floor_price_check (last used: 2026-01-15)

Reply 'archive all stale' | 'delete candidates' | 'review list'

This is the human-in-the-loop pattern at its best: the agent does the analysis, surfaces the decision, and waits for authorization before doing anything irreversible. Deletion is a reversible action only if you archived first — so the default should be archive-then-delete-after-confirm.

The near-duplicate audit is worth running separately. Skills with semantically similar names often represent the same capability created twice. A weekly embedding-based similarity check (cosine similarity > 0.9) can flag pairs for manual deduplication.

Common Mistakes

Not tracking last-invoked timestamps. If you do not instrument skill invocations from day one, you cannot run the Curator. Add the timestamp tracking before you ship the first skill — retrofitting it later requires auditing every invocation path.

Treating all skills equally. Some skills are invoked seasonally — quarterly reporting scripts, for example. A 30-day staleness threshold will flag them every year. Add an exempt_from_curation: true flag for known seasonal skills.

Deleting without archiving. Context rot is a cost problem, not a correctness problem. The cure (deletion) should not introduce a new problem (losing skills you will want again). Archive to cold storage; delete permanently only after 90 additional days of non-use.

Only curating skills, not memory. Context rot affects everything in your agent's context window: skills, memory files, tool descriptions, system prompts. Apply the same lifecycle thinking to all of them. A MEMORY.md that has grown to 500 lines is causing the same degradation as 50 stale skills.

Summary

  • Context rot is the accumulation of unused skills that waste tokens and degrade model attention
  • The Skill Curator lifecycle: active (0-30 days) → stale (30-90 days) → archived/deleted (>90 days)
  • Both thresholds are configurable — default 30/90 days works well for most teams
  • Track last_invoked timestamps on every skill invocation from day one
  • Archive before deleting; make permanent deletion a separate, confirmed step
  • Context rot applies to memory files, not just skills — curate all context sources

What's Next

The next lesson moves to level 4: cron automation. You describe recurring tasks in plain English — "daily 3am backup of my notes folder" — and the agent writes, registers, and monitors the cron job itself. This is where the agent starts handling work you never have to think about again.