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
Install
npx skills add https://github.com/markoblogo/abvx-agent-skills/tree/main/skills/loopops-protocol
claude plugin marketplace add https://llmmart.ai/marketplace.json && claude plugin install markoblogo-abvx-agent-skills@llmmart
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.
Reviews (0)
No reviews yet.
No comments yet.