What makes Ber Clawhub V060 notable?

1.4K downloads. Trust evidence available

How should Ber Clawhub V060 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

Ber Clawhub V060

Better Every Run: capture explicit /ber corrections, review them, and promote only the lessons that deserve durable memory, skill rules, or evals.

OpenClaw

View on ClawHub Homepage

Rank

Safety

Downloads

1.4k

Updated

Oct 10, 2026

Version

0.6.0

Source

CLAWHUB

About

What it does, and when to use it.

Capability contract not published. No trust telemetry is available yet. 1.4K downloads reported by the source. Last updated 10/10/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 10, 2026
Protocol compatibility: OpenClawcompatibility · observed Oct 10, 2026
Adoption signal: 1.4K downloadsadoption · observed Oct 10, 2026
Latest release: 0.6.0release · observed Sep 1, 2026
Handshake status: UNKNOWNsecurity

Install and run

Setup complexity: low.

clawhub skill install s1754kcncc002avbhpwjnqgcr98728et:better-every-run

Install using `clawhub skill install s1754kcncc002avbhpwjnqgcr98728et:better-every-run` in an isolated environment before connecting it to live workloads.
No published capability contract is available yet, so validate auth and request/response behavior manually.
Review the upstream CLAWHUB listing at https://clawhub.ai/leostehlik/better-every-run before using production credentials.

Contract: missing

curl -s "https://www.xpersona.co/api/v1/agents/clawhub-leostehlik-better-every-run/snapshot"

Documentation

CLAWHUB

149,240 characters of source documentation, loaded on request.

Extracted files

5 files captured from the source.

SKILL.md

---
name: ber
description: "Better Every Run: capture explicit /ber corrections, review them, and promote only the lessons that deserve durable memory, skill rules, or evals."
user-invocable: true
metadata:
version: "0.6.0"
---
# Better Every Run

Use this skill only when the user explicitly invokes `/ber`, names Better Every Run, or directly asks to persist a lesson for future runs. BER turns deliberate corrections into reviewed lessons without silently converting ordinary chat into permanent memory. Do not auto-capture ordinary corrections, casual preferences, or words like "remember", "always", "never", or "next time" unless the user clearly wants durable learning.

The human path is deliberately small:

```text
/ber fix bad outcome -> desired outcome
/ber remember simple rule
/ber report
```

The agent runs the bundled local helper and reports the result in chat. `fix` and `remember` record only to the local `.better-every-run/` evidence store. Durable memory/skill changes require the reviewed `card` + `promote` flow; eval regression cases require `eval-fixture`.

## When To Use

- The user explicitly types `/ber fix ... -> ...`.
- The user explicitly types `/ber remember ...`.
- The user explicitly asks for a Better Every Run report.
- The user asks the agent to record a reusable correction as durable memory.

## Human Commands

```text
/ber fix agent wrote vague status -> agent gives exact command output and next action
/ber remember use the approved development host for active code work
/ber report
```

## Rules

- Report CLI output back in chat; do not build web pages or dashboards.
- Do not silently edit `MEMORY.md`, `AGENTS.md`, `SOUL.md`, or other durable instruction files.
- Do not pass `--target` to `/ber fix` or `/ber remember`; direct durable writes are disabled and must refuse.
- Only promote to durable memory or skill files after an explicit review decision using `card` then `promote`.
- Memory promotions must target an existing `memory/*.md` file.
- Skill promotions must target `SKILL.md` in the current skill project.
- Eval fixtures must use `eval-fixture` and target `.json` or `.jsonl` under `tests/` or `evals/`.
- Scanner hard blocks and warnings both block promotion. Adjust, quarantine, or supersede the lesson instead of forcing it through.
- Keep corrections factual: bad outcome, desired outcome, and scope.
- Use scope metadata when it helps decide whether a lesson belongs only to this run, the project, the workspace, a skill, memory, or an eval.
- Avoid private data unless the user explicitly wants it captured.
- Keep the user-facing flow short, but disclose persistence: local store, durable target file if promoted, and how it was reviewed.
- Design for the shortest path to the user's outcome.
- Never publish `.better-every-run/` state, local lessons, event logs, or private corrections.

## Workflow

For normal chat use, keep the visible flow to one command:

```text
/ber fix bad outcome -> desired outcome
```

For simpl

README.md

# Better Every Run

Teach the agent from explicit corrections without turning chat into permanent memory.

Better Every Run gives a correction a clean path: capture it locally, review whether it deserves to stick, then promote it to memory, a skill rule, or an eval only when the evidence is good. Nothing is learned from casual chat by accident.

```text
/ber fix vague status update -> exact command output and next action
/ber remember design software for humans from the shortest path to outcome
/ber report
```

The useful part is the boundary. The agent can improve from a sharp correction, but it still has to say what was recorded, where it lives, and whether anything durable changed.

**v0.6 focus:** a concrete before/after correction artifact: bad repeated agent behavior -> explicit `/ber fix` -> local lesson card -> later run improves without silently rewriting durable memory.

## Start Here

```bash
git clone https://github.com/LeoStehlik/better-every-run.git
cd better-every-run
make test
```

Then read `SKILL.md` and `examples/upstream-loop.md` to see the governed correction flow.

## Install

### OpenClaw / ClawHub

```bash
openclaw skills install better-every-run
```

### Manual

```bash
git clone https://github.com/LeoStehlik/better-every-run.git ~/.openclaw/workspace/skills/better-every-run
```

For Claude Code, Codex, or other agent harnesses, copy this folder into the harness skill directory and load `SKILL.md`.

## Conversion Proof

BER is easiest to understand as a before/after loop:

![Before and after BER correction flow](assets/ber-before-after-correction.svg)

Read the compact proof story in [`examples/before-after-correction.md`](examples/before-after-correction.md). It shows the bad behavior, the exact `/ber fix`, what gets stored locally, what does not get promoted automatically, and how the later run changes.

## Human Surface

Use BER when the human explicitly wants a lesson recorded:

```text
/ber fix vague status update -> exact command output and next action
/ber remember design software for humans from the shortest path to outcome
/ber report
```

The agent handles the local helper, then tells the human whether the lesson stayed in the project-local `.better-every-run/` store or was promoted through a reviewed durable flow.

## Works With

BER is written as an OpenClaw skill, but the pattern is portable to any agent runner that can load a `SKILL.md` file and run the bundled helper. It fits Codex, Claude Code, OpenCode, Hermes, and custom multi-agent harnesses that need explicit learning without silent memory writes.

## Product Rule

- The skill runs only from explicit `/ber` use or a direct request to persist a lesson.
- Humans should not manage helper internals during normal use.
- `/ber fix` and `/ber remember` never append directly to durable files, even when `--target` is supplied.
- The agent should summarize the outcome in chat, including the local store and any reviewed durable promotion.
- Lesson metadata should

_meta.json

{
  "ownerId": "kn7d3r58cdxk8k0xg6jq6k65gs873c0c",
  "slug": "better-every-run",
  "version": "0.6.0",
  "publishedAt": 1788224886727
}

references/report-template.md

# Report Template

Use this shape when summarizing Better Every Run output in chat:

```text
Better Every Run report:

- Events captured: N
- Lessons accepted: M
- Open proposals: K
- Promotion suggestions: P
- Quarantined/superseded/expired: Q/S/X
- Local store: `.better-every-run/`
- Durable files changed: none or `<path>`

Captured lessons:
1. ...
2. ...

No open proposals. Create a lesson card before durable promotion. Promote only lessons that should become memory, skill behavior, or eval coverage; quarantine or supersede the rest. No durable memory file was changed unless listed above.
```

Keep the user-facing report short. Mention internal commands only when debugging or auditing.

references/workflow.md

# Better Every Run Workflow

Better Every Run is for small, factual learning moments that the user explicitly wants persisted.

OpenClaw command name: `ber`.

## Normal Human Path

Use one command for outcome corrections:

```text
/ber fix agent used wrong host for code work -> agent uses the approved development host
```

The agent handles the helper command and reports the result. Normal `fix` and `remember` commands write only to `.better-every-run/`. Use `--scope` when the lesson has an obvious destination: `run`, `project`, `workspace`, `skill`, `memory`, or `eval`. Use `--expires YYYY-MM-DD` for temporary rules, or `--expires never` for explicit long-lived lessons.

For simple preferences:

```text
/ber remember do code work on the approved development host
```

## Internal Capture

Capture only evidence that would change future behavior and was explicitly requested through `/ber` or direct durable-learning instruction:

```bash
node scripts/ber.js capture --type correction --note "Do code work on the approved development host." --tags workspace,coding
```

Good captures:

- User explicitly asks `/ber fix ... -> ...`.
- User explicitly asks `/ber remember ...`.
- User directly asks to record a reusable workflow or safety boundary.
- A tool recovery path is reusable and the user approves capturing it.

Bad captures:

- Generic advice the base agent already knows.
- Private details unrelated to future behavior.
- Speculation without observed evidence.
- Casual chat containing words like "remember", "always", "never", or "next time" without clear durable-learning intent.

## Propose

Turn recent evidence into lesson proposals:

```bash
node scripts/ber.js propose --today
```

Proposals are not policy. They are review candidates.

## Report

Return the report in chat:

```text
/ber report
```

Keep the chat report short. Include local storage status and any open proposed lessons.

## Promote To Memory Or Skill

This flow is for agents, audits, tests, and explicit durable writes. In normal chat, summarize the result instead of making the human operate helper commands, but disclose any durable target file.

```bash
node scripts/ber.js card <lesson-id> --to memory --target memory/decisions.md
node scripts/ber.js promote <lesson-id> --to memory --target memory/decisions.md
node scripts/ber.js card <lesson-id> --to skill --target SKILL.md
node scripts/ber.js promote <lesson-id> --to skill --target SKILL.md
```

Lesson cards record target hashes and scanner verdicts before promotion. Promotion appends a reviewable block only if the target has not changed since the card was written and the scanner verdict is clean.

## Promote To Eval

Eval durability uses a structured fixture command, not markdown append promotion:

```bash
node scripts/ber.js eval-fixture <lesson-id> --target tests/ber-regressions.json
```

Eval fixture targets must be `.json` or `.jsonl` files under `tests/` or `evals/`.

## Lifecycle Hygiene

Use quarantine and supersession to kee

Github ReposUpdated 21h 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.