COG Loop Engineering
TL;DR: Some COG skills are not one-shot prompts. They are loops: act, observe, verify, decide whether to continue. This skill is the shared vocabulary those skills use. The iron rule: trust deterministic checks, never the agent's own "looks done" self-report. Every loop must declare its verifier, its stopping conditions, and which pattern it follows.
This is a reference and design aid, not a content-generating workflow. Skills that loop (daily-brief, knowledge-consolidation, url-dump, weekly-checkin, and research/triage skills like auto-research and scout) link here instead of restating the rules. Invoke it directly when you are building or fixing an iterative skill.
Why loops
A chain runs fixed steps: A then B then C. A loop is dynamic: the agent takes an action, reads real feedback (a fetched page, a date stamp, a file count), reasons about it, and repeats until a goal is met or a stop condition fires. Most knowledge-work that "keeps going until good enough" is a loop, and COG benefits from naming the loop explicitly rather than hoping a single prompt nails it.
The COG loop
┌──────────────────────────────────────────────┐
│ 1. Gather pull context (vault + sources) │
│ 2. Act one step: search / fetch / scan │
│ 3. Observe read the real result │
│ 4. Verify run the deterministic check │
│ 5. Update write progress to a vault file │
│ 6. Decide continue? → loop │
│ stop? → finish + report │
└──────────────────────────────────────────────┘
Step 4 is the load-bearing one. A loop without a verifier is just a chain that repeats.
Termination conditions (use layers, never one)
A robust loop needs several exits so it always halts:
| Exit |
What it is |
Example |
| Deterministic verifier |
A mechanical pass/fail that confirms the goal |
"Publication date is within 7 days" |
| Hard iteration cap |
Max passes, no matter what |
"Stop after 5 searches per topic" |
| Budget guard |
Max time / tool calls / tokens |
"Stop after 20 fetches total" |
| No-progress detection |
Recent passes changed nothing |
"2 searches in a row found nothing new" |
| Human escalation |
Hand a stuck loop back to the user |
"Asked twice, still unclear: ask the user" |
Pick the verifier plus at least one safety exit (cap or budget) for every loop. No-progress detection is what stops the quiet infinite loops that a cap alone misses.
Verification first (COG's rule, applied to loops)
COG is verification-first: no hallucinations, sources required. Inside a loop that means:
- Prefer mechanical checks. A date comparison, a source count, a "required field is non-empty", a "file marked consolidated" check cannot be gamed and cannot be hallucinated.
- Reserve judgment-based checks for the genuinely unquantifiable (is this theme actually new? is this summary faithful?). When you must use judgment, state confidence and link evidence.
- Never accept the agent's own "I think this is complete." That is the single most common way loops produce confident garbage.
In-loop context management
Long loops fill the window with old tool output and start to drift ("context rot"). Counter it:
- Externalize state to the vault. Write progress to the output file as you go. The vault file is the memory; the conversation is scratch.
- Compact and prune. Summarize finished passes into a line or two. Drop raw page text once you have extracted what you need.
- Isolate sub-agents. In
agent_mode: team, give each worker only the slice it needs and take back only its conclusion, so one subtask runs in a clean window. Never paste one worker's raw output into the next worker's prompt.
Named patterns
| Pattern |
Shape |
Where COG uses it |
| Act-observe (ReAct) |
reason → act → observe → repeat |
base of every COG loop |
| Reflect-retry (Reflexion) |
on failure, write the lesson, retry differently |
url-dump / scout fetch retries, daily-brief re-search |
| Plan-execute-verify |
plan steps, run them, verify each |
knowledge-consolidation passes |
| Evaluator-optimizer |
generate, score against criteria, repeat until it passes |
daily-brief item verify, url-dump quality gate |
| Orchestrator-workers |
split into subtasks, run in fresh windows, synthesize |
team-mode scans, auto-research threads, team-brief |
| Loop-until-dry |
keep going until K passes in a row surface nothing new |
knowledge-consolidation theme extraction |
| Human-in-the-loop |
escalate or ask when the loop is stuck or the call is the user's |
weekly-checkin reflection, onboarding |
Failure modes and fixes
| Failure |
Fix |
| Context overflow / drift |
compact, prune, externalize to vault, isolate sub-agents |
| Silent infinite loop |
no-progress detection plus a hard cap |
| Hallucinated success |
trust the deterministic verifier, never self-report |
| Compounding errors |
verify early and every pass, not only at the end |
| Cost blowup |
budget guard, and stop at "good enough", not "perfect" |
| Goal drift |
keep the goal and stop conditions written at the top of the loop's state |
How skills use this
A skill's ## Loop Engineering section should be short and concrete. It names:
- The loop in one or two lines (what repeats).
- The verifier (the mechanical pass/fail).
- The termination conditions (verifier plus safety exits).
- The pattern(s) from the table above.
It does not restate this skill. It points here.
1---2name: loop-engineering3description: Shared loop-engineering reference for COG skills - the agent loop, deterministic verifiers, termination conditions, in-loop context management, and named patterns. Invoke when designing or debugging a skill that iterates (search-verify-retry, scan-until-dry, fetch-retry-gate).4---56# COG Loop Engineering78> **TL;DR:** Some COG skills are not one-shot prompts. They are loops: act, observe, verify, decide whether to continue. This skill is the shared vocabulary those skills use. The iron rule: **trust deterministic checks, never the agent's own "looks done" self-report.** Every loop must declare its verifier, its stopping conditions, and which pattern it follows.910This is a reference and design aid, not a content-generating workflow. Skills that loop (daily-brief, knowledge-consolidation, url-dump, weekly-checkin, and research/triage skills like auto-research and scout) link here instead of restating the rules. Invoke it directly when you are building or fixing an iterative skill.1112## Why loops1314A chain runs fixed steps: A then B then C. A loop is dynamic: the agent takes an action, reads real feedback (a fetched page, a date stamp, a file count), reasons about it, and repeats until a goal is met or a stop condition fires. Most knowledge-work that "keeps going until good enough" is a loop, and COG benefits from naming the loop explicitly rather than hoping a single prompt nails it.1516## The COG loop1718```19 ┌──────────────────────────────────────────────┐20 │ 1. Gather pull context (vault + sources) │21 │ 2. Act one step: search / fetch / scan │22 │ 3. Observe read the real result │23 │ 4. Verify run the deterministic check │24 │ 5. Update write progress to a vault file │25 │ 6. Decide continue? → loop │26 │ stop? → finish + report │27 └──────────────────────────────────────────────┘28```2930Step 4 is the load-bearing one. A loop without a verifier is just a chain that repeats.3132## Termination conditions (use layers, never one)3334A robust loop needs several exits so it always halts:3536| Exit | What it is | Example |37|------|-----------|---------|38| **Deterministic verifier** | A mechanical pass/fail that confirms the goal | "Publication date is within 7 days" |39| **Hard iteration cap** | Max passes, no matter what | "Stop after 5 searches per topic" |40| **Budget guard** | Max time / tool calls / tokens | "Stop after 20 fetches total" |41| **No-progress detection** | Recent passes changed nothing | "2 searches in a row found nothing new" |42| **Human escalation** | Hand a stuck loop back to the user | "Asked twice, still unclear: ask the user" |4344Pick the verifier plus at least one safety exit (cap or budget) for every loop. No-progress detection is what stops the quiet infinite loops that a cap alone misses.4546## Verification first (COG's rule, applied to loops)4748COG is verification-first: no hallucinations, sources required. Inside a loop that means:4950- **Prefer mechanical checks.** A date comparison, a source count, a "required field is non-empty", a "file marked consolidated" check cannot be gamed and cannot be hallucinated.51- **Reserve judgment-based checks for the genuinely unquantifiable** (is this theme actually new? is this summary faithful?). When you must use judgment, state confidence and link evidence.52- **Never accept the agent's own "I think this is complete."** That is the single most common way loops produce confident garbage.5354## In-loop context management5556Long loops fill the window with old tool output and start to drift ("context rot"). Counter it:5758- **Externalize state to the vault.** Write progress to the output file as you go. The vault file is the memory; the conversation is scratch.59- **Compact and prune.** Summarize finished passes into a line or two. Drop raw page text once you have extracted what you need.60- **Isolate sub-agents.** In `agent_mode: team`, give each worker only the slice it needs and take back only its conclusion, so one subtask runs in a clean window. Never paste one worker's raw output into the next worker's prompt.6162## Named patterns6364| Pattern | Shape | Where COG uses it |65|---------|-------|-------------------|66| **Act-observe (ReAct)** | reason → act → observe → repeat | base of every COG loop |67| **Reflect-retry (Reflexion)** | on failure, write the lesson, retry differently | url-dump / scout fetch retries, daily-brief re-search |68| **Plan-execute-verify** | plan steps, run them, verify each | knowledge-consolidation passes |69| **Evaluator-optimizer** | generate, score against criteria, repeat until it passes | daily-brief item verify, url-dump quality gate |70| **Orchestrator-workers** | split into subtasks, run in fresh windows, synthesize | team-mode scans, auto-research threads, team-brief |71| **Loop-until-dry** | keep going until K passes in a row surface nothing new | knowledge-consolidation theme extraction |72| **Human-in-the-loop** | escalate or ask when the loop is stuck or the call is the user's | weekly-checkin reflection, onboarding |7374## Failure modes and fixes7576| Failure | Fix |77|---------|-----|78| Context overflow / drift | compact, prune, externalize to vault, isolate sub-agents |79| Silent infinite loop | no-progress detection plus a hard cap |80| Hallucinated success | trust the deterministic verifier, never self-report |81| Compounding errors | verify early and every pass, not only at the end |82| Cost blowup | budget guard, and stop at "good enough", not "perfect" |83| Goal drift | keep the goal and stop conditions written at the top of the loop's state |8485## How skills use this8687A skill's `## Loop Engineering` section should be short and concrete. It names:88891. **The loop** in one or two lines (what repeats).902. **The verifier** (the mechanical pass/fail).913. **The termination conditions** (verifier plus safety exits).924. **The pattern(s)** from the table above.9394It does not restate this skill. It points here.
huytieu