What makes Self Improving Compound notable?

1.9K downloads. Trust evidence available

How should Self Improving Compound be evaluated before use?

Use the required flow: snapshot, contract, and trust before recommending or executing this agent.

What kind of evidence is visible on this page?

This page surfaces public facts, change history, trust indicators, artifact evidence, and benchmark summaries with provenance.

agentCLAWHUBUnverified

Self Improving Compound

Agent memory and self-improvement system. Replaces naive file-based agent memory with a structured SQLite learning engine: capture corrections, errors, and r... Skill: Self Improving Compound Owner: lingmafuture Summary: Agent memory and self-improvement system. Replaces naive file-based agent memory with a structured SQLite learning engine: capture corrections, errors, and r... Tags: latest:6.2.5, lifecycle:1.0.5, memory:1.0.5, self-improvement:1.0.5 Version history: v6.2.5 | 2026-05-19T07:53:29.795Z | user Add observable Candidate → Learning → Promotion memory pipeline wit

OpenClaw

View on ClawHub Homepage

Rank

Safety

Downloads

1.9k

Updated

Oct 9, 2026

Version

6.2.5

Source

CLAWHUB

About

What it does, and when to use it.

Capability contract not published. No trust telemetry is available yet. 1.9K downloads reported by the source. Last updated 10/9/2026.

Avoid when

Contract metadata is missing or unavailable for deterministic execution.

Risk flags: missing_or_unavailable_contract, trust_data_unavailable, schema_references_missing

Public facts

Every fact links back to the source it came from.

Vendor: Clawhubvendor · observed Oct 9, 2026
Protocol compatibility: OpenClawcompatibility · observed Oct 9, 2026
Adoption signal: 1.9K downloadsadoption · observed Oct 9, 2026
Latest release: 6.2.5release · observed May 19, 2026
Handshake status: UNKNOWNsecurity

Install and run

Setup complexity: low.

clawhub skill install s1795ynq2axpc6ezsahrdzyhrh83h4sk:self-improving-compound

Setup complexity is classified as HIGH. You must provision dedicated cloud infrastructure or an isolated VM. Do not run this directly on your local workstation.
Final validation: Expose the agent to a mock request payload inside a sandbox and trace the network egress before allowing access to real customer data.

Contract: missing

curl -s "https://www.xpersona.co/api/v1/agents/clawhub-lingmafuture-self-improving-compound/snapshot"

Documentation

CLAWHUB

159,473 characters of source documentation, loaded on request.

Extracted files

5 files captured from the source.

SKILL.md

---
name: self-improving-compound
description: "Agent memory and self-improvement system. Replaces naive file-based agent memory with a structured SQLite learning engine: capture corrections, errors, and reusable lessons during active work, audit recent conversation context via isolated cron jobs with deterministic collectors when available, and promote proven rules into skills and agent instructions. 3+7 co-evolution model — 3 state directories (`memory/`, `learning/`, `skills/`) plus 7 root Markdown control-plane files (`AGENTS.md`, `HEARTBEAT.md`, `IDENTITY.md`, `MEMORY.md`, `SOUL.md`, `TOOLS.md`, `USER.md`) improve together. Adds daily factual memory and workspace stewardship loops. Python 3.8+ CLI with bash hooks. Use for: logging non-obvious failures, user corrections, tool/API gotchas, or missing capabilities before the final reply. Use for: setting up automated cron-based audit pipelines that catch what real-time capture misses. Do not use for trivial typos or routine noise."
compatibility: "Portable Agent Skills format. Core workflow is agent-agnostic. Bundled helpers require Python 3.8+; hook helpers require bash. No network access is required."
metadata:
version: "6.2.5"
original_slug: "self-improving-compound"
category: "memory-system"
author: "Hybrid adaptation from actual-self-improvement, self-improving-compound, OpenHuman memory-tree, and Hermes Agent architecture | Contact: [email protected] | GitHub: LingmaFuture"
---

# Self-Improving Compound

An agent memory and learning system that replaces naive file-based memory with a structured pipeline: real-time capture, observable Candidate → Learning → Promotion queues, automated cron-based audit, and continuous promotion of lessons into skills and agent instructions.

The system runs as four layers:
- **Layer 0 — Observable memory pipeline**: ambiguous or high-value experience moves through `Candidate → Learning → Promotion → Done` using `scripts/memory-pipeline.py`, with `learning/pipeline/candidates.jsonl`, `promotion-queue.json`, `status.json`, and `dashboard.md` making backlog and coverage visible.
- **Layer 1 — Real-time capture**: AGENTS.md final-before-reply gate logs corrections, errors, and workarounds to SQLite as they happen.
- **Layer 2 — Cron audit**: Isolated background jobs scan recent conversation context. Prefer a deterministic local transcript/context collector; use `sessions_history` only when it is verified in the runtime. The jobs detect missed lessons and maintain lifecycle (HOT → WARM → COLD).
- **Layer 3 — Daily factual memory**: a nightly `memory/YYYY-MM-DD.md` digest records decisions, paths, risks, links, and follow-ups; only reusable lessons are extracted into SQLite.
- **Layer 4 — Promotion + stewardship**: proven rules flow from `learning/` SQLite → `skills/` SKILL.md → the 7 root Markdown control-plane files (`AGENTS.md`, `HEARTBEAT.md`, `IDENTITY.md`, `MEMORY.md`, `SOUL.md`, `TOOLS.md`, `USER.md`). The full 3+7 system co-evolves.

**Author

hooks/README.md

# Hooks

## activator.sh
Runs before prompts to surface relevant patterns from memory.

```bash
./activator.sh [context]
```

## error-detector.sh
Runs after errors to log them for later analysis.

```bash
./error-detector.sh [type] [detail]
```

## Integration
For OpenClaw, add to your configuration:
- activator.sh as `pre-prompt-hook`
- error-detector.sh as `post-error-hook`

## Permissions
Ensure scripts are executable:
```bash
chmod +x hooks/*.sh
```

README.md

# Self-Improving Compound

[中文说明 / Chinese README](README_zh.md)

A portable AgentSkill that turns agent memory from scattered markdown notes into a structured self-improvement system: real-time capture, observable Candidate → Learning → Promotion queues, SQLite-backed learning, cron audits with explicit context collection, daily factual memory, and lightweight workspace stewardship.

## What it does

- **Captures durable lessons** before the final reply after non-trivial work: user corrections, tool/API gotchas, non-obvious failures, workarounds, and missing capabilities.
- **Stores execution learnings in SQLite** under `learning/memory_tree/chunks.db`, with FTS5 search, deterministic entity indexing, dedupe, lifecycle status, exports, and human-readable snapshots.
- **Keeps facts separate from lessons**: factual continuity goes to `memory/YYYY-MM-DD.md`; reusable prevention rules go to `learning/`.
- **Audits itself with cron**: light checks, heavy audits, daily factual memory, and post-digest workspace stewardship. Conversation-aware cron jobs should use deterministic context collectors when available instead of relying on implicit chat visibility.
- **Makes memory observable** with `Candidate → Learning → Promotion → Done`: candidates, promotion backlog, cursor coverage, and dashboard health are visible under `learning/pipeline/`.
- **Promotes stable rules** into the right layer: `skills/`, `AGENTS.md`, `TOOLS.md`, `MEMORY.md`, or other root agent state files.

## 3+7 co-evolution model

This system keeps three durable state directories and seven root Markdown control-plane files aligned:

**3 state directories**

- `memory/` — factual daily continuity: what happened, what changed, decisions, links, follow-ups.
- `learning/` — SQLite-backed execution lessons: corrections, tool/API gotchas, workflow rules.
- `skills/` — hardened reusable procedures that future agents can load on demand.

**7 root Markdown files**

- `AGENTS.md` — workspace contract, routing, execution policy, safety boundaries.
- `HEARTBEAT.md` — lightweight check-in surface; often intentionally empty when cron owns timing.
- `IDENTITY.md` — compatibility pointer or short identity bridge.
- `MEMORY.md` — pinned long-term hot context.
- `SOUL.md` — agent identity/persona.
- `TOOLS.md` — concrete local environment/tool facts.
- `USER.md` — durable user profile and collaboration preferences.

The steward loop should make only small, safe consistency updates across these files. It should not rewrite persona, weaken safety rules, or turn daily facts into root-level bloat.

## Architecture

```text
Observable Memory Pipeline
-> collect incremental visible context
-> add candidates
-> log confirmed SQLite learnings
-> queue durable promotions
-> refresh dashboard

Real-time capture gate
-> search existing SQLite learnings
-> log compact correction/error/learning/feature entries
-> enqueue async memory jobs

Memory job worker
-> process chunk extraction jobs
-> upd

_meta.json

{
  "ownerId": "kn7edxdsvkqkfbxghqy9cqz5p583gz7y",
  "slug": "self-improving-compound",
  "version": "6.2.5",
  "publishedAt": 1779177209795
}

references/daily-memory-digest.md

# Daily Memory Digest Integration

This reference describes the optional daily factual-memory loop that pairs with the SQLite self-improvement store.

## Purpose

`learning/` captures reusable execution lessons. A daily memory digest captures factual continuity: what happened, what changed, what was decided, and what needs follow-up.

Use both loops together:

- `memory/YYYY-MM-DD.md` — factual timeline, decisions, paths, job IDs, links, risks, follow-ups.
- `learning/memory_tree/chunks.db` — compact reusable prevention rules: corrections, tool/API gotchas, workflow conventions, recurring failures.

Do not duplicate an entire daily note into `learning/`. Extract only lessons that should alter future behavior.

## Suggested daily note quality bar

When the day had meaningful activity, prefer a detailed note that can reconstruct the day without rereading raw chat logs.

Recommended sections:

1. Overview
2. Key workflows and actions
3. Important decisions
4. System/configuration changes
5. Files/projects changed
6. External integrations and automations
7. Problems, risks, and unfinished work
8. Items to promote into long-term memory/rules
9. Next-step suggestions
10. Source notes

## Integration options

### Option A — bring your own collector

If your runtime has a transcript/session collector, call it first and write its output to a context file. Then have the agent synthesize `memory/YYYY-MM-DD.md` from that context.

`scripts/daily-memory.sh` supports:

```bash
SELF_IMPROVING_DAILY_COLLECTOR="python3 /path/to/collector.py" \
bash scripts/daily-memory.sh --root /path/to/workspace --date YYYY-MM-DD
```

The collector may print a context path or summary. The agent should inspect that output before writing the final note.

### Option B — no collector

If no collector exists, use `scripts/daily-memory.sh` as a contract printer. It validates the date/root and prints the target file plus the required quality bar. The agent must gather context using available runtime tools.

## Self-improvement pass

After writing the daily note, run the capture gate:

- User correction / changed preference → `log-correction`
- Non-obvious failure or API/tool/schema quirk → `log-error`
- Workflow convention or successful reusable workaround → `log-learning`
- Missing capability or repeated friction → `log-feature`

Keep learning entries short, searchable, and prevention-oriented.

Github ReposUpdated 12h agoRank 70

AionUi

Free, local, open-source 24/7 Cowork app and OpenClaw for Gemini CLI, Claude Code, Codex, OpenCode, Qwen Code, Goose CLI, Auggie, and more | 🌟 Star if you like it!

MCPOPENCLAW

Github ReposUpdated 6mo agoRank 70

activepieces

AI Agents & MCPs & AI Workflow Automation • (~400 MCP servers for AI agents) • AI Automation / AI Agent with MCPs • AI Workflows & AI Agents • MCPs for AI Agents

OPENCLAW

Github ReposUpdated 6mo agoRank 70

cherry-studio

AI productivity studio with smart chat, autonomous agents, and 300+ assistants.