evolving-lite

Evolving Lite

Claude Code that learns from you. Install once. Work normally. The system remembers what worked, learns from your corrections, and gets better every session - without you lifting a finger.

"I corrected Claude about checking tsconfig strict mode first. A week later, different project, similar type error - Claude checked strict mode before I said anything. That's when I stopped thinking of it as a plugin."

See It In Action

2 min demo: Claude recalls past decisions, learns from a correction, and applies it automatically - no prompt needed.

Self-Star Doctor (/health)

Evolving Lite ships its own install-time health assistant. The Self-Star Doctor runs a synthetic pulse through every junction of the self-improving loop and prints a green/yellow/red board:

 ✓ delegation       GREEN  synthetic prompt -> valid delegation decision row
 ✓ fitness          GREEN  event -> bounded cognitive-fitness score, read back
 ✓ autoevolve       GREEN  optimizer present, kill-switches OK, one scored cycle
 ✓ steward          GREEN  zero false findings on a clean repo
 ✓ verifier-spine   GREEN  EPT spine resolves; markerless claim blocked
 ✓ security         GREEN  tier-check classifies + scanner flags a planted secret
 ✓ kairn-link       GREEN  Kairn installed + reachable

It runs once automatically on your first session and is re-runnable any time with /health. It heals conservatively (creates only missing empty scaffolding, asks before touching settings.json, never overwrites or deletes) and runs its pulse in an isolated scratch copy, so it never touches your real data.

What Makes This Different

Most Claude Code tools add features. Evolving Lite adds feedback loops.

It learns from corrections. Say "No, check tsconfig first" once. The system detects the correction, stores it, and recalls it automatically when a similar situation comes up - across sessions, across projects.

It activates progressively. Session 1: safety net only. Session 3: learning kicks in. Session 10: deep memory. You're never overwhelmed, and each tier earns trust before the next one activates.

It heals itself. Every hook writes a sentinel file proving it ran. Run the health-monitor agent to check all sentinels - silent failures don't stay silent.

It gets leaner, not fatter. Old experiences decay. Stale sessions get archived. The system prunes itself so it stays fast at month 6 the same way it was at day 1.

Self-Evolution is ON

Evolving Lite self-tunes its own delegation config from your sessions out of the box. AutoEvolve watches the outcomes of delegation decisions and adjusts the routing config when it sees a real, repeated signal. This is the headline feature - and it is on by default - so here is exactly how it is kept safe and how to turn it off.

Guardrails that ship with it (so a fresh install never tunes on noise):

• It holds fire on thin data: no config mutation happens for a task type until it has crossed a minimum sample threshold (N=8 real outcomes). A day-1 install mutates nothing.
• An asymmetric trust model (lose-trust-fast) plus a floor prevents a single bad batch from swinging the config.
• A no-regression guard: a proposed mutation only persists if it scores at least as well as the current static baseline. Anything below baseline is automatically reverted and logged.
• It is per-target: only targets that empirically improve self-tune; the rest stay off.

Turn it off in one step. Set this in _graph/cache/delegation-config.json:

"mutation_rules": { "v2_tuning_enabled": false }

That halts all config self-tuning immediately.

Inspect / revert what it changed. Every reverted mutation is recorded in _autoevolve/rejected/. Applied changes live in _graph/cache/delegation-config.json (plain JSON) - diff it against git to see exactly what moved, and revert any line by hand.

Note: this switch controls only AutoEvolve's config self-tuning. The separate autonomy layer (the unsupervised /autonom-style loop with the EPT stop-gate) ships off by default and is a deliberate, documented opt-in.

Honest Scope