SteerPack

Lightweight rule lifecycle governance for LLM agents.

February 2025. Meta's AI Alignment Director types "don't action until I approve" into OpenClaw. Context compaction silently drops the rule. The agent deletes 200+ emails. Three "STOP" commands are ignored.

July 2026. SOUNDGATE (arXiv:2607.14166) proves this is systemic: across all 6 major frameworks, pre-execution gates fail. 215 of 1,200 runs leak side effects during an approval pause.

Meanwhile, tools like LangMem and Mem0 auto-extract "rules" from your sessions — but they only add. They never deduplicate. Never deprecate. Never ask "does this conflict with your existing rules?"

SteerPack is the layer that fixes this. It doesn't replace your agent framework. It governs the rules that govern your agents.

What SteerPack Does

                    LangMem / Letta / Mem0
                    (auto-extract rules)
                              │
                              │ candidate rules
                              ▼
              ┌───────────────────────────────┐
              │      ADMISSION PIPELINE        │  ← SteerPack
              │  human review · conflict check │
              │  admit / reject / modify       │
              └──────────────┬────────────────┘
                             │ admitted rules
                             ▼
              ┌───────────────────────────────┐
              │      RULE STORE                │  ← SteerPack
              │  lifecycle state machine       │
              │  proposed→active→deprecated    │
              │  metadata · conflicts · expiry │
              └──────────────┬────────────────┘
                             │ export
                             ▼
         ┌───────────────────┼───────────────────┐
         ▼                   ▼                   ▼
   Claude Code           Cursor            OpenHarness

• Rule Lifecycle State Machine: Every rule has a state — proposed → admitted → active → deprecated → retired. Every rule carries metadata: where it came from, what it conflicts with, when it expires, how often it's triggered.
• Human Adjudication Pipeline: Receives candidate rules from LangMem, Mem0, and Letta. Runs conflict detection against your existing rules. Shows you the diff. Records every admit/reject decision.
• Mid-Execution Watchdog: Monitors agent traces for goal drift, self-contradiction, domain switches, and long verification gaps. Triggers GRILL when scope changes mid-task — extending grill-me from "before you start" to "while you're running."
• Cross-Harness Portable Export: One steerpack.yaml exports to Claude Code, Cursor, and OpenHarness format. Your rules travel with you.

What SteerPack Is NOT

• ❌ Not a new agent framework — rides on OpenHarness, Claude Code, Cursor, LangGraph
• ❌ Not a CLAUDE.md linter — ccinspect, rulox, and agint already do that well. We delegate to them.
• ❌ Not an enterprise control plane — Nexus Agents and Galileo Agent Control cover fleet management. We're for individual developers.
• ❌ Not an auto-memory extractor — LangMem, Letta, and Mem0 are upstream. We govern what they produce.

Quick Start

pip install steerpack

# Day 1: Transform your flat CLAUDE.md into a governed rule pack
steerpack init -f ~/.claude/CLAUDE.md
steerpack list
# * ACTIVE (12):
#    rule-001  Tab indentation for Python    [python, style]
#  - DEPRECATED (3):
#    rule-004  Use Python 3.9 features only  [python]

# Day 2: Ingest auto-extracted rules from Mem0/LangMem, then adjudicate
steerpack ingest -f mem0_session.json
# Ingested 5 candidate rules. 2 have conflicts — review with 'steerpack admit'
steerpack admit    # interactive: [A]dmit / [R]eject / [S]kip per rule

# Day 3: Export active rules to any harness
steerpack export -t claude-code -o ~/.claude/CLAUDE.md
steerpack export -t cursor      -o .cursorrules
steerpack export -t openharness   # prints MCP resource JSON to stdout

# Day 3: Watch for goal drift while your agent runs
steerpack watch -t agent_trace.json -k "fix the null check in login handler"
# !! [GRILL] goal_drift: Step 10 rewrites database pool — not in original task

Why This Exists

1. Rules evaporate under context compaction (OpenClaw incident, 2025). Prompt-level instructions are not durable. Rules need to live outside the context window.
2. Auto-extracted rules pile up with no governance (MPR paper, arXiv:2509.03990). LangMem/Mem0/Letta only add. Someone needs to deduplicate, deprecate, and reject.
3. Agents drift mid-task with no one watching (SOUNDGATE, arXiv:2607.14166). grill-me aligns before coding. Nothing watches during execution.
4. Rules written for one harness don't work in another. MCP solved tool portability. Nobody solved instruction portability.

Prior Art

SteerPack did not emerge from a vacuum. We mapped the entire agent governance landscape before writing a single line of code. See PRIOR_ART.md for:

• Verified pain points with original sources
• 19 existing tools and papers analyzed, with gaps identified
• Why each gap remains unfilled (training coupling, architecture cost, commercial incentives)
• SteerPack's exact position relative to each

Design Decisions

Every non-obvious choice is recorded in ADMISSION_LOG.md — our own rule pack demonstrating the product. Includes: why Python, why zero-dependency, why we don't build a linter, why we don't implement agent loop, why watchdog is advisory not enforcer.

Development

git clone https://github.com/EvanCaoCosmos/steerpack.git
cd steerpack
pip install -e ".[dev]"
pytest

Status: Pre-alpha. Rule object model defined. CLI and watchdog in development. See ADMISSION_LOG.md for the full roadmap.

License

MIT