SIPS — Self-Improvement Plugin System

A self-improvement harness for Claude Code and ChatGPT / Codex. SIPS wraps a coding-agent session with memory-aware startup, safer tool use, verification hooks, bounded fresh-context delegation, and session closeout — so long-running sessions remember prior work, avoid repeated mistakes, recover from drift, and capture lessons before the context window disappears.

It does not try to make an agent smarter by swapping models. It improves the work loop around whatever model you already run.

SIPS 0.11 — visual evidence and explainable memory reuse. Compose tools with declared units, roles and context identities; inspect dependency drift; run bounded diagnostic policies against recorded probe outcomes. Frozen behavioral cases independently evaluate proposed policies. Passing tests never activate a change automatically. Workflow and migration guide.

Companion app: a very very very experimental, free, native macOS control surface — Swift Harness.

Each session can answer:

• What did we learn last time?
• Is this edit risky?
• Did the changed script still pass a smoke check?
• Is this task stuck enough to split out?
• What should future sessions remember?
• Which agent patterns have worked or failed before?

Suggested GitHub topics: agent-harness, ai-agents, claude-code, codex, memory-fabric, self-improvement, automation, evals, python, developer-tools

Supported hosts

SIPS installs as a plugin in either harness, from the same repo:

• Claude Code — reads .claude-plugin/marketplace.json (marketplace sips-local).
• ChatGPT / Codex — reads .agents/plugins/marketplace.json (marketplace harness-local).

Delegation agents declare model: inherit, so they run on whatever model the host session already uses. The plugin never depends on a specific model or on model swaps; the gain comes from context control, scoped recall, verification, and recorded outcomes.

Install

Claude Code

/plugin marketplace add RasputinKaiser/Self-Improvement-Plugin

Then install harness-self-improvement from the marketplace UI.

ChatGPT / Codex

Add the repo as a local marketplace, then install:

harness-self-improvement@harness-local

Requirements

Runtime scripts resolve $SIPS_HOME first, otherwise ~/.codex/sips. Retired host directories are never a runtime fallback. The SIPS-owned Memory Fabric subsystem is vendored in-repo — no external memory plugin is required.

What it adds

Adaptive core

observe → diagnose → propose → build → evaluate → ready_for_review

The active task agent writes the candidate; SIPS owns evidence, frozen evaluation, durable state, and review. Activation and rollback require an explicit reviewed candidate digest. The homebase_adaptation_read and homebase_adaptation_write MCP tools share the same controller as the CLI. NCode is retired; Codex is primary and Claude Code compatibility is retained.

Core workflow

A typical session looks like this:

1. Session starts.
2. The harness validates itself.
3. Memory Fabric health is checked.
4. Prior patterns and lessons are surfaced.
5. The user submits a task.
6. Relevant prior lessons are ranked and injected.
7. Before risky edits, preflight checks run.
8. After tool use, smoke checks and escalation checks run.
9. Before compaction, a continuity packet is written.
10. After compaction, session learnings are recorded.
11. At stop, the task outcome is captured for future pattern analysis.

The intent is to make each session leave behind useful state instead of vanishing into a transcript.

Slash commands

Delegation agents

Delegation agents keep the parent session from getting overloaded. Each agent gets a bounded job and returns a focused result instead of taking over the whole task. All agents use model: inherit.

Lifecycle hooks

Hook commands are portable: they run python3 against ${PLUGIN_ROOT} and fall back to ${CLAUDE_PLUGIN_ROOT}, with the plugin-root path quoted so it survives spaces in the install path. The event tap is silent by default; set SIPS_DEBUG=1 to write hook failure details to logs/hook_errors.jsonl.

By phase:

• Startup — validate_harness.py (harness health), memory_fabric_doctor.py (memory health + recent work), proactive_drift.py (drift and untested scripts), agent_patterns.py --brief (success/failure brief), improvement_injector.py (loop-closure guidance).
• Prompt submit — recall_ranker.py (ranks prior lessons for the prompt and scope), probe_hook.py (markers for hook tests).
• Before tool use — autonomy_gate.py (blocks or warns on risky autonomous actions), memory_fabric_preflight.py (surfaces lessons before edits).
• After tool use — script_smoke.py (syntax/smoke checks changed scripts), escalation_advisor.py (flags when a bounded escalation may help), sips_presence_mirror.py (mirrors SIPS presence files into the local host surface).
• Compaction — memory_fabric_compact_brief.py and compact_continuity.py preserve continuity before compaction; memory_fabric_session_record.py records learnings after.
• Stop — session_close.py (session closeout), task_outcome_tracker.py --record (outcome capture for pattern analysis).

SIPS Homebase MCP

.mcp.json exposes scripts/harness_homebase_mcp.py as sips-homebase — a portable control plane shared by Claude Code and Codex.

Codex skill surface

SIPS exposes compact skill rows for the major Homebase surfaces, so the plugin reads like a real toolbelt rather than a bare list of MCP servers and hooks:

Current release — v0.8.0

SIPS now issues resumable work packets to the active task agent, tests evaluator
sensitivity against frozen wrong implementations, and links subsequent authored
evaluations to reviewed candidates. Evaluation receipts are content-pinned.
Unknown probe predictions no longer count as contradictions.

Read the foreground workflow and API. All 0.7 advisory methods
remain available. Optimize remains 0.6.0. Local foreground replays and proposed
procedure reuse are recorded separately from independently controlled transfer
experiments; broad self-improvement effectiveness remains unmeasured.

Status matrix

Verify

Run the manifest coherence check (fails if EVAL.md has drifted):

python3 scripts/validate_v2.py --check-eval

Regenerate EVAL.md explicitly:

python3 scripts/validate_v2.py --write-eval

Run the regression harness and the pytest suite:

python3 scripts/run_tests.py            # local core regression harness
python3 scripts/run_tests.py homebase_mcp

python3 -m pip install ".[dev]"
pytest                                  # complete regression collection

Utility reference

Validation & testing

SIPS Memory Fabric (vendored under scripts/memory_fabric*.py)

Self-improvement & pattern analysis

Recovery & maintenance

Delegation, goals & plumbing

Design notes

This plugin is built around a few rules:

1. Memory should show up before it matters, not after the mistake.
2. Verification should run close to the edit that caused the risk.
3. Escalation should be bounded, not a second uncontrolled agent session.
4. Session closeout should produce useful future signal.
5. The harness should be able to inspect and improve itself without hiding what changed.

Related project

Swift Harness is the companion macOS GUI. Use this plugin for the harness logic; use Swift Harness when you want a native desktop control surface for status, tests, memory, snapshots, hooks, browser control, evals, agents, telemetry, and plugin surfaces.

Security

This plugin runs local scripts and reads local harness state. Review the scripts before using them in another environment. Do not paste secrets, tokens, private transcripts, or private repo content into public issues. See SECURITY.md for vulnerability reporting.

Contributing

Contributions are welcome through issues and pull requests. See CONTRIBUTING.md before opening larger changes.

License

MIT. See LICENSE.

Improve skills and tools during a run

When evidence exposes stale instructions, a reusable workflow, or a tool defect,
SIPS can capture an improvement notice without changing the active task's scope.
The sips-in-run-improvement skill routes creation, extension, refresh and repair;
opportunities supplies a source-checked handoff to an isolated candidate. See
the in-run workflow. Shared changes still require
independent checks and exact-candidate activation; useful task-local findings can
inform the current task immediately.

Episode and dependency diagrams plus explicit procedure-rejection reasons are available through visual evidence views.