Claude Skill

loopops-protocol

Design and evolve agent skills into cost-bounded loops, workflows, scripts, and memory updates. Use when creating or auditing reusable agent methods, converting prompts or skills into workflows, designing open or closed agent loops, defining supervisor/evaluator contracts, or dec

LLM Mart · 0 points · 2 views 0 listing impressions 0 install-command copies
Download markoblogo-abvx-agent-skills-skills_loopops-protocol-37a7146.zip · 3 KB

Install

skills CLI npx skills add https://github.com/markoblogo/abvx-agent-skills/tree/main/skills/loopops-protocol
Claude Code claude plugin marketplace add https://llmmart.ai/marketplace.json && claude plugin install markoblogo-abvx-agent-skills@llmmart
Git git clone https://github.com/markoblogo/abvx-agent-skills.git

The skills CLI installs just this skill, for any of its supported agents. Claude Code installs the whole markoblogo/abvx-agent-skills collection as a plugin from our marketplace. Git is the plain clone.

Skill manifest

LoopOps Protocol

Use this skill when reusable agent behavior should become more than a better prompt.

The goal is to choose the smallest durable artifact that improves future runs:

prompt -> skill -> checklist -> script -> workflow -> loop

Do not promote work upward unless the extra machinery buys reliability, reuse, or cheaper future execution.

Artifact Ladder

Classify the candidate method first:

  • Prompt: one-off instruction for this run.
  • Skill: compact reusable context, procedure, or tool adapter loaded on demand.
  • Checklist: ordered human/agent validation sequence.
  • Script: deterministic repeatable action with parameters.
  • Workflow: ordered tool/process execution with gates and evidence.
  • Loop: workflow plus evaluator, memory write, retry policy, and stop rule.

Prefer the lowest artifact that handles the task reliably.

Loop Suitability Gate

Promote a workflow into a loop only when all are true:

  • The goal has an observable completion condition.
  • Progress can be evaluated without trusting the worker agent blindly.
  • A retry is likely to improve the result.
  • Cost can be bounded by iteration, time, token, or tool budget.
  • Failure has a clear stop, rollback, or human-escalation path.

If any condition is missing, keep it as a supervised workflow or checklist.

Open vs Closed Loop

Use an open loop when:

  • the solution space is unknown,
  • discovery or exploration matters,
  • multiple valid approaches may exist,
  • the output is research, architecture, strategy, or design direction.

Use a closed loop when:

  • acceptance criteria are known,
  • tests, checks, or review criteria exist,
  • regression risk matters,
  • the task can be decomposed into verifiable steps.

Open loops need tighter budget limits. Closed loops need stronger evaluators.

Supervisor Contract

Every loop must define:

Goal:
Completion condition:
Loop type: open | closed
Worker action:
Evaluator:
Evidence:
Memory write:
Retry policy:
Budget:
Stop rule:
Rollback or escalation:

The evaluator can be a test command, lint/typecheck/build, browser check, static analysis, script, human review, or a separate model. Prefer deterministic evaluators when available.

Memory Policy

After each iteration, save only durable signal:

  • current hypothesis,
  • changed files or artifacts,
  • verification result,
  • blocker or failure mode,
  • next intended action,
  • reusable lesson if it generalizes.

Do not append raw logs, long transcripts, secrets, private data, or one-off observations to durable memory.

Skill Evolution

After a loop completes, update skills only with lessons that are:

  • procedural,
  • reusable,
  • testable,
  • not already covered by higher-priority instructions,
  • worth their token cost.

Good updates:

  • missing repo-specific command,
  • repeated failure mode,
  • verification step that caught a real issue,
  • script or workflow that replaced repeated manual work,
  • rejected path that should not be retried.

Bad updates:

  • generic coding advice,
  • motivational wording,
  • model-behavior hacks,
  • single-incident preferences,
  • rules that increase context without reducing errors.

Cost Controls

Every loop must have at least two:

  • max iterations,
  • max wall-clock time,
  • max token/tool budget if measurable,
  • narrowest useful verification first,
  • summarized memory instead of raw logs,
  • stop after repeated identical blocker,
  • human approval before external, destructive, expensive, or privacy-sensitive actions.

If cost cannot be bounded, do not run autonomously.

Compiler Rule

When the same step is repeated three times, decide whether to compile it:

  • repeated prose instruction -> skill rule,
  • repeated checklist -> workflow,
  • repeated shell/Python/JS snippet -> script,
  • repeated verification pattern -> evaluator,
  • repeated failure recovery -> stop hook or escalation rule.

Prefer scripts and deterministic checks over longer instructions.

Final Report

When designing or updating a loop-capable method, report:

  • chosen artifact level,
  • why higher levels were rejected or accepted,
  • supervisor contract if a loop is used,
  • cost controls,
  • memory writes,
  • validation performed,
  • skill/workflow/script files changed.
Files (abvx-agent-skills)
  • agents
    • openai.yaml 245 B
      Loading…
  • SKILL.md 4.7 KB
    ---
    name: loopops-protocol
    description: Design and evolve agent skills into cost-bounded loops, workflows, scripts, and memory updates. Use when creating or auditing reusable agent methods, converting prompts or skills into workflows, designing open or closed agent loops, defining supervisor/evaluator contracts, or deciding whether repeated agent work should become a skill, checklist, script, workflow, or autonomous loop.
    license: MIT
    metadata:
      abvx_status: experimental
      abvx_origin: original
    ---
    
    # LoopOps Protocol
    
    Use this skill when reusable agent behavior should become more than a better prompt.
    
    The goal is to choose the smallest durable artifact that improves future runs:
    
    ```text
    prompt -> skill -> checklist -> script -> workflow -> loop
    ```
    
    Do not promote work upward unless the extra machinery buys reliability, reuse, or cheaper future execution.
    
    ## Artifact Ladder
    
    Classify the candidate method first:
    
    - **Prompt**: one-off instruction for this run.
    - **Skill**: compact reusable context, procedure, or tool adapter loaded on demand.
    - **Checklist**: ordered human/agent validation sequence.
    - **Script**: deterministic repeatable action with parameters.
    - **Workflow**: ordered tool/process execution with gates and evidence.
    - **Loop**: workflow plus evaluator, memory write, retry policy, and stop rule.
    
    Prefer the lowest artifact that handles the task reliably.
    
    ## Loop Suitability Gate
    
    Promote a workflow into a loop only when all are true:
    
    - The goal has an observable completion condition.
    - Progress can be evaluated without trusting the worker agent blindly.
    - A retry is likely to improve the result.
    - Cost can be bounded by iteration, time, token, or tool budget.
    - Failure has a clear stop, rollback, or human-escalation path.
    
    If any condition is missing, keep it as a supervised workflow or checklist.
    
    ## Open vs Closed Loop
    
    Use an **open loop** when:
    
    - the solution space is unknown,
    - discovery or exploration matters,
    - multiple valid approaches may exist,
    - the output is research, architecture, strategy, or design direction.
    
    Use a **closed loop** when:
    
    - acceptance criteria are known,
    - tests, checks, or review criteria exist,
    - regression risk matters,
    - the task can be decomposed into verifiable steps.
    
    Open loops need tighter budget limits. Closed loops need stronger evaluators.
    
    ## Supervisor Contract
    
    Every loop must define:
    
    ```text
    Goal:
    Completion condition:
    Loop type: open | closed
    Worker action:
    Evaluator:
    Evidence:
    Memory write:
    Retry policy:
    Budget:
    Stop rule:
    Rollback or escalation:
    ```
    
    The evaluator can be a test command, lint/typecheck/build, browser check, static analysis, script, human review, or a separate model. Prefer deterministic evaluators when available.
    
    ## Memory Policy
    
    After each iteration, save only durable signal:
    
    - current hypothesis,
    - changed files or artifacts,
    - verification result,
    - blocker or failure mode,
    - next intended action,
    - reusable lesson if it generalizes.
    
    Do not append raw logs, long transcripts, secrets, private data, or one-off observations to durable memory.
    
    ## Skill Evolution
    
    After a loop completes, update skills only with lessons that are:
    
    - procedural,
    - reusable,
    - testable,
    - not already covered by higher-priority instructions,
    - worth their token cost.
    
    Good updates:
    
    - missing repo-specific command,
    - repeated failure mode,
    - verification step that caught a real issue,
    - script or workflow that replaced repeated manual work,
    - rejected path that should not be retried.
    
    Bad updates:
    
    - generic coding advice,
    - motivational wording,
    - model-behavior hacks,
    - single-incident preferences,
    - rules that increase context without reducing errors.
    
    ## Cost Controls
    
    Every loop must have at least two:
    
    - max iterations,
    - max wall-clock time,
    - max token/tool budget if measurable,
    - narrowest useful verification first,
    - summarized memory instead of raw logs,
    - stop after repeated identical blocker,
    - human approval before external, destructive, expensive, or privacy-sensitive actions.
    
    If cost cannot be bounded, do not run autonomously.
    
    ## Compiler Rule
    
    When the same step is repeated three times, decide whether to compile it:
    
    - repeated prose instruction -> skill rule,
    - repeated checklist -> workflow,
    - repeated shell/Python/JS snippet -> script,
    - repeated verification pattern -> evaluator,
    - repeated failure recovery -> stop hook or escalation rule.
    
    Prefer scripts and deterministic checks over longer instructions.
    
    ## Final Report
    
    When designing or updating a loop-capable method, report:
    
    - chosen artifact level,
    - why higher levels were rejected or accepted,
    - supervisor contract if a loop is used,
    - cost controls,
    - memory writes,
    - validation performed,
    - skill/workflow/script files changed.
    
  • SKILL_CARD.md 2.5 KB
    Loading…

Comments (0)

Sign in to join the conversation.

No comments yet.

Reviews (0)

No reviews yet.