Episodic memory records successful task completions as reusable examples. When the agent successfully creates an API endpoint, the full sequence (plan, implementation, tests, review) is saved. Next time a similar task arises, this episode is loaded as a few-shot example, dramatically improving first-attempt quality.

The task description (what was requested).

The plan (how the agent approached it).

The implementation (key files changed).

Review feedback (what was corrected).

Final result (the approved version).

This gives future agents a complete picture of how to handle similar tasks.

When a new task arrives, the harness searches episodic memory for similar past tasks. The most relevant episode is loaded into context as a few-shot example. The agent sees: “Here’s how a similar task was completed successfully. Follow this pattern.” This is more effective than abstract instructions because it shows the agent a concrete, approved example.

Few-shot examples from episodic memory can improve first-attempt quality by 40–60% compared to instructions alone. The agent doesn’t just know the rules — it sees what a correct implementation looks like in your specific codebase. This is especially powerful for complex tasks with many implicit conventions.

Codebase entropy is the gradual degradation of code quality and consistency over time. With human developers, entropy accumulates slowly. With AI agents generating code at high velocity, entropy can accumulate 10× faster. Slightly different naming conventions, subtly inconsistent patterns, gradually diverging module structures.

Naming drift: Some modules use getUserById, others use fetchUser, others use loadUserData.

Pattern drift: Error handling is done differently in each module.

Documentation drift: README says one thing, code does another.

Constraint drift: CLAUDE.md rules don’t match actual code patterns.

Constraint violation scanners periodically scan the entire codebase for deviations from the constraint document. Unlike linters (which check individual files), scanners check cross-file consistency: Are all API endpoints following the same pattern? Are all error messages formatted consistently? Do all modules use the same dependency injection approach?

Scanners can be rule-based (grep for patterns, count inconsistencies) or LLM-based (ask a model to review the codebase for consistency). Rule-based scanners are cheaper and more reliable for known patterns. LLM-based scanners can catch subtle inconsistencies that rules miss.

Cleanup agents are scheduled agents that run periodically to reduce entropy. They scan for inconsistencies, generate fix PRs, and submit them for review. Unlike coding agents (which add new code), cleanup agents normalize existing code to match current conventions.

Documentation consistency: Update READMEs and comments to match current code.

Naming normalization: Rename functions and variables to match current conventions.

Pattern enforcement: Refactor code to use the current standard pattern.

Dead code removal: Find and remove unused functions, imports, and files.

Documentation drifts from code faster than any other artifact. API docs describe endpoints that no longer exist. READMEs reference deprecated patterns. The CLAUDE.md itself may contain rules that no longer match the codebase. Stale documentation is worse than no documentation because it actively misleads the agent.

A documentation consistency agent compares documentation against the actual codebase and flags discrepancies. It can run after every significant PR merge to check whether the change invalidated any existing documentation. When it finds a discrepancy, it either auto-fixes or creates a ticket for human review.

Error pattern tracking logs every mistake the agent makes across all sessions: what the agent did wrong, what the correct action was, and what constraint or rule would have prevented it. Over time, this builds a failure taxonomy — a structured catalog of how agents fail in your specific codebase.

The failure taxonomy drives harness improvement: frequent failures become new lint rules or constraint document entries. Rare but severe failures become structural tests. Novel failures get investigated to understand whether they represent a new failure mode or a one-off. The taxonomy turns reactive firefighting into proactive prevention.

Just as token budgets manage context window usage, an entropy budget manages the rate of codebase change. If agents are merging 100 PRs per week, the codebase is changing faster than humans can review for consistency. Setting limits on the rate of change — and scheduling cleanup proportionally — keeps entropy manageable.

For every 10 feature PRs, schedule 1 cleanup PR. This 10:1 ratio keeps entropy from accumulating.

Weekly consistency scans catch drift before it compounds.

Monthly constraint document reviews ensure rules match reality.

Quarterly architecture audits verify the big picture is still coherent.