ulw-loop
A goal-like loop that decomposes work into systematic, evidence-bound ultrawork steps
Install / Use
npx skills add code-yeongyu/oh-my-openagent --skill ulw-loopInstalls into whichever agent you are using.
SKILL.md
Installable skill definition
Quality Score
Category
AutomationSupported Platforms
Our assessment of ulw-loop
ulw-loop scores 92/100 on our quality scale, 803rd of 2,790 Automation skills we index (top 29%).
Its SKILL.md is 12 KB long, split into 7 sections with 1 code example: a thorough specification that gives an agent plenty to work with.
With 69,362 GitHub stars, it is one of the more widely adopted skills in the catalogue.
Maintenance, license and trust
- The repository was last updated about 2 months ago, so ulw-loop is actively maintained.
- No license is declared. By default that means all rights are reserved: you can read it, but reusing or redistributing it is not clearly permitted. Ask the author before building on it commercially.
- Its trust signals score 88/100, with 1 caution from licensing, adoption, age or documentation. These come from repository metadata, not a code audit — read the skill file before letting an agent act on it.
Safety scan
No issues foundOur scan of the whole file found no instruction hijacking, hidden characters, credential access, data exfiltration or destructive commands. An AI review of the same text found nothing harmful.
AI review by kimi-k2.7-code on 2026-09-26. Automated pattern scan on 2026-09-26. It catches known dangerous patterns, not every risk — read a skill before letting an agent act on it.
ulw-loop compared with similar skills
All 4 of these similar skills score higher than ulw-loop; compare them before choosing.
| Skill | Score | Stars | Updated | Format |
|---|---|---|---|---|
| ulw-loop (this skill)by code-yeongyu | 92 | 69.4k | 53d ago | SKILL.md |
| taste-skillby Leonxlnx | 100 | 116.8k | 8d ago | CLAUDE.md |
| Agent-Reachby Panniantong | 100 | 112.3k | 8d ago | CLAUDE.md |
| rufloby ruvnet | 100 | 81.9k | today | CLAUDE.md |
| Claude-Code-Game-Studiosby Donchitos | 100 | 39.7k | 7d ago | CLAUDE.md |
Frequently asked questions
- How do I install ulw-loop?
- Run
npx skills add code-yeongyu/oh-my-openagent --skill ulw-loop. The install tabs above show the steps for each supported agent. - Which AI agents does ulw-loop work with?
- It is written for Universal, as a SKILL.md file. Other agents that read the same format can often use it too.
- Is ulw-loop safe to use?
- Our scan of the whole file found no instruction hijacking, hidden characters, credential access, data exfiltration or destructive commands. An AI review of the same text found nothing harmful. It declares no license and scores 88/100 on trust signals. Skills are instructions an agent will follow, so read the file before installing it and do not approve commands you do not understand.
- Is ulw-loop still maintained?
- The repository was last updated about 2 months ago, so ulw-loop is actively maintained.
Skill content
View source on GitHubname: ulw-loop description: "A goal-like loop that decomposes work into systematic, evidence-bound ultrawork steps. Use when the user wants a goal loop or durable, checkpointed execution." metadata: short-description: Goal-like ultrawork loop for systematic decomposition
ulw-loop
Use this skill when the user asks for ulw-loop, ulw, durable goal execution, evidence-led work, manual QA, or checkpointed long-running delivery.
This skill is compact by design: the run contract below is the whole bootstrap. references/full-workflow.md and references/define-goal.md carry the full doctrine; open a section only when the phase you are in needs it.
Run contract
- Create goals from a JS eval cell:
agentToolkit.createGoals({ brief })after the SDK import below. The SDK binds this session from the host env, so never pass a session id or a plan path. If the envelope reportsULW_LOOP_PLAN_EXISTS_COMPLETE(this session's aggregate is already complete), unrelated new work needs a fresh session;createGoals({ brief, force: true })is only for deliberately overwriting completed evidence. - Register the aggregate objective from the returned handoff with
create_goal, shaped byreferences/define-goal.md. Goal creation is NEVER skipped. - Mirror every atomic step into the live
todochecklist: one granular step per action, exactly one in_progress, transitions marked the instant they happen. - Treat each goal as a phase: create its own worktree off the integration base; dispatch its dependency-ordered lanes as ONE
workflowrun (read the mass-ulw skill first; ordering-free lanes stay ataskbatch); verify every criterion with real-surface evidence; land the worktree on the integration base atagentToolkit.checkpoint({ goalId, status: "complete", evidence })per the repository's flow (direct merge or merged PR); define the next goal's run from what this one proved. Tests alone never prove done. When a mass-ulw pointer accompanies this skill, this contract still owns goals, criteria, evidence, and checkpoints. - Stop when the goal's WHEN-TO-STOP line holds with evidence in hand.
When the injected ultrawork directive accompanies this skill, its goal/notepad/todo bootstrap is subsumed by this contract: the loop SDK owns goal state and the loop ledger is the notepad. Do not create a second one.
The SDK: one import, then method calls
Every ulw-loop operation runs inside a JS eval cell through the SDK the extension publishes at OMO_AGENT_TOOLKIT_SDK_ROOT. There is no omo_agent_toolkit tool and no CLI to spawn on Senpi.
const { agentToolkit } = await import(`${env("OMO_AGENT_TOOLKIT_SDK_ROOT")}/sdk.js`)
print(await agentToolkit.status())
Rules that keep it working:
- JS cells only. From a py, rb, or jl cell, run a separate eval with language
js. - Import once per kernel lifetime.
agentToolkitstays bound in later cells; re-import only after a kernel restart or aReferenceError: agentToolkit is not defined. - Every call resolves to an envelope, never a throw:
{ ok: true, operation, result, nextActions, warnings? }or{ ok: false, operation, error: { code, message }, warnings? }.nextActionsare things to do next;warningsare facts to know (a fallback the binder took, a driver objective that differs). ReadnextActionsbefore deciding the next step, and branch onerror.code, not on the message text. - Never pass a session id or plan path. The SDK binds
PI_SESSION_IDandPI_SESSION_CWDfrom the host env on each call; state lives under.omo/ulw-loop/<session-id>/. WhenPI_SESSION_CWDis missing (seen after an extension reload restarted the kernel), the binder falls back to the cwd recorded in thePI_SESSION_FILEheader, then toprocess.cwd(), and every envelope carries a warning naming the fix:env("PI_SESSION_CWD", "<session cwd>").status().result.bindingshows{ cwd, cwdSource, sessionId, goalStorePaths }, so check it after any kernel restart and re-pin the env whencwdSourceis notPI_SESSION_CWD. - The driver snapshot is filled automatically from this session's goal store. Pass
codexGoalJsononly to override it.
Methods (argument fields are exact):
| Method | Args |
|---|---|
| help() | none; result.operations[] carries method (the camelCase name to call), args (field -> type, ? = optional), description, mutating — enough to recover every call below after a kernel restart |
| status() | none; result carries plan, summary, nextActions, evidenceRoot (stable plan-level artifact dir), currentAttemptDir (moves with the active goal), binding (cwd, cwdSource, sessionId, goalStorePaths), driver (available, status, objectiveMatchesPlan, objectiveAcknowledged) |
| createGoals(args) | { brief, codexGoalMode?, force?, validationBatchesJson? } |
| completeGoals(args?) | { retryFailed? }; acquires the next eligible goal or resumes the in-progress one |
| criteria(args) | { goalId } |
| recordEvidence(args) | { goalId, criterionId, status: "pass" \| "fail" \| "blocked", evidence, notes?, artifacts? }; every artifacts path must exist (resolved against the session cwd, ULW_LOOP_EVIDENCE_ARTIFACT_MISSING otherwise) and is stored on the criterion and the ledger entry, repo-relative when inside the cwd |
| checkpoint(args) | { goalId, status: "complete" \| "failed" \| "blocked", evidence, codexGoalJson?, qualityGateJson? }, or { printTemplate: true, goalId? } for the quality-gate template |
| steer(args) | { kind, source: "finding", evidence, rationale, ...kind fields }; kinds and their fields are in references/full-workflow.md |
| addGoal(args) | { title, objective, successCriteria? } with successCriteria: [{ scenario, expectedEvidence, userModel?, essential? }]; omit it and the three seeded placeholders name the exact steer({ kind: "revise_criterion", ... }) call that replaces each one |
| recordReviewBlockers(args) | { goalId, title, objective, evidence, codexGoalJson? } |
Non-Negotiables
- Write loop state only through the SDK; it lives under
.omo/ulw-loop/<session-id>/and is never hand-edited. Mutations are serialized across processes by the session's.state.lock, so parallelrecordEvidencecalls from workers are safe. - Register goals up front, shaped by
references/define-goal.md(agentToolkit.createGoals({ brief }), thencreate_goalfrom the returned handoff), and mirror every atomic step into the livetodochecklist: one ultra-granular step per action, exactly one in_progress, transitions marked the instant they happen. - After any compaction or context loss, re-read brief + goals + ledger FIRST plus
agentToolkit.status()(re-import the SDK if the kernel restarted;help()lists every method with its argument fields), confirmresult.binding.cwdSourceisPI_SESSION_CWDand re-pin it withenv("PI_SESSION_CWD", result.binding.cwd)when it is not, then resume; never re-plan from scratch. - If
createGoalsanswersULW_LOOP_PLAN_EXISTS_COMPLETE, this session's aggregate is already done: start unrelated new work in a fresh session instead of steering or forcing the completed state. Useforce: trueonly to intentionally overwrite completed evidence. - Every success criterion needs observable evidence from a real surface: a channel (terminal/TUI via the xterm.js web terminal, HTTP, browser, computer-use) or, for CLI- or data-shaped criteria, an auxiliary surface (CLI stdout, DB diff, parsed config dump).
- Evidence is bound to the tree it was captured at (
git rev-parse --short "HEAD^{tree}"); it goes stale only when tracked content changes — a rebase or amend that keeps the tree identical keeps it valid. When the tree differs, re-run at the current HEAD and re-record, never relabel or regenerate. Record only after cleanup receipts exist. - Delegate code edits, test writes, fixes, and QA execution to right-sized omo-senpi subagents through the native
tasktool or throughworkflownodes when the phase's lanes carry ordering. - Use
git-masterfor git-tracked edits: inspect recent and touched-path commit history, then commit each verified work unit atomically in the repository's observed language, scope, and message style with only that unit's files staged. Never carry verified units into a later omnibus commit.
Team mode: decide it, do not default to it
Solo execution with parallel background task workers is the default: fan independent units out in one batched spawn, each routed to the category (or configured subagent_type) that fits it, with scopes cut so no two workers write the same files. A team (team_create) adds per-member briefing, shared-state, and relay overhead, so it must be paid for by the work's shape. Decide ONCE, when the plan's work units are known, and record the verdict plus its reason in the notepad.
Stand up a team when BOTH hold:
- The units' scopes overlap in a way you cannot cleanly cut. They touch the same module, contract, or migration, so one unit's discovery changes what another should do. Fire-and-forget workers cannot exchange that mid-flight; teammates can, because the lead relays it.
- Running them at the same time actually finishes sooner. The units are each substantial and none is merely waiting on another's output. Two units where the second only consumes the first's result are a sequence, not a team.
When the units are genuinely independent — separate files, no shared contract — spawn parallel background task workers instead and avoid the team coordination overhead entirely. When the work is one cohesive unit, do it yourself. Overlap alone is not enough: near-identical units that would collide on the same lines are faster done in sequence by one worker.
Under team mode, isolate and land per unit:
- One git worktree per member, never a shared checkout — concurrent members editing one working tree corrupt each other's diffs and evidence. Give each member its own branch off the base and its own worktree path.
- Merge per work unit, as each unit is verified. A member's unit lands when its own evidence is captured and its gates are green; it does not wait for the slowest sibling. Integrate each merged unit back into the base the others branch from, so overlapping members rebase onto real merged work rather than guessing at it.
- Conflicts are the lead's job. When two members' units touch the same lines, the lead decides the order they land and tells the later member what changed; members never resolve a sibling's conflict blind.
Native Senpi Task Contract
Senpi already exposes its real subagent spawn surface through the omo-senpi task component. Use it directly. Do not route delegation through external app-server threads or another harness.
| Intent | Native Senpi tool |
| --- | --- |
| Spawn one worker | task({ prompt, subagent_type | category, run_in_background: true }) |
| Fan out independent workers | task({ tasks: [{ prompt, subagent_type | category }, ...], run_in_background: true }) |
| Send context or correction | task_send({ task_id, message }) |
| Inspect one midpoint | task_output({ task_id, mode: "tail" }) |
| Stop a runaway worker | task_cancel({ task_id }) |
| Coordinate overlapping work | team_create, task_create, task_get, task_list, task_update; communicate with task_send |
Every worker prompt starts with TASK: and names DELIVERABLE, SCOPE, VERIFY, and STOP WHEN. Put requested skill names and all required context inside prompt; children do not inherit interview context automatically.
Driver goal lifecycle
The session goal you create with create_goal is a DRIVER the loop instructs, never a gate. A checkpoint accepts an optional driver snapshot, records it verbatim, and never rejects on its status or objective; the advice comes back in nextActions. The snapshot is filled from this session's goal store automatically, so pass codexGoal only t
Truncated for display — read the full file on GitHub.
Related Skills
taste-skill
116.8kAgent skills that give coding agents taste: art direction, reference images and a browser check instead of generic AI pages
Agent-Reach
112.3kGive your AI agent eyes to see the entire internet. Read & search Twitter, Reddit, YouTube, GitHub, Bilibili, XiaoHongShu — one CLI, zero API fees.
ruflo
81.9k🌊 The original agent harness. Deploy intelligent multi-player swarms, coordinate autonomous workflows, and build conversational AI systems. Features adaptive memory, self-learning intelligence, federation, vector RAG integration, and native Claude Code / Codex / Hermes and many more Integrated
Claude-Code-Game-Studios
39.7kTurn Claude Code into a full game dev studio — 49 AI agents, 72 workflow skills, and a complete coordination system mirroring real studio hierarchy.
Languages
Trust signals
From repository metadata: license, adoption, age and documentation. Not a code audit — see the Safety scan above for what the skill file itself contains.
