Dev & Engineering acceptance-testinggate-checkingtask-decompositionparallel-orchestrationprompt-engineeringcodex-cli

Unlazy Completion Discipline

Keep AI agents from finishing early with deep decomposition, acceptance ledgers, and executable gates.

FollowAgents review · FARS-2.1
Recommended
86/ 100 5-point scale 4.3 / 5
1 2 3 4 5 6
1Trust25 / 29 · 4.3/5

Least privilege is addressed through read-only CI permissions, commit-pinned actions, and approval storage outside the checked repository, but gate commands still inherit the user's filesystem, environment, credentials, and network access, so this is not complete containment. User confirmation is thorough: an unapproved oracle is displayed rather than executed, approval is bound to the exact command context, and hook installation is explicitly invoked. Data flows and external effects are clearly documented, including ledger evidence, approval records, hook state, settings writes, PATH disclosure, and absolute-path exposure. Sensitive-data guidance warns against secret-bearing output and recommends review and isolation, but there is no automatic environment scrubbing, secret detection, or sandbox. Runtime code has no third-party packages and CI actions are pinned to commits, supporting full dependency-security credit. Uninstall, atomic settings writes, and backups provide useful recovery, but arbitrary effects produced by CHECK commands have no general rollback. Research sources, license authorship, and contributor-history routes are well attributed; the publisher remains unverified by the enterprise registry, which is treated as unknown rather than suspicious.

2Reliability11 / 14 · 3.9/5

README, SECURITY, package metadata, and CI configuration consistently describe the Node requirement, zero runtime dependencies, approval boundary, inherited shell environment, and test command. Dependency availability is handled with Node 16+ requirements, a three-OS and multi-version CI matrix, and warnings about unavailable shell utilities, but user-defined gates may still depend on arbitrary tools in the launch environment. The documentation identifies rejected ledger forms, invalid expectations, timeouts, and fail-closed lock behavior; however, the supplied evidence excludes implementation source and representative diagnostic output, so consistently actionable failure messages cannot be fully established.

3Adaptability18 / 18 · 5.0/5

The material addresses solo work, hierarchical agent work, parallel leaves, parent reverification, Claude Code, and Codex, with distinct guidance for authors and orchestrators. Capability boundaries are unusually explicit: approval is not sandboxing, leases are not write isolation, a gate proves only its declared oracle, and extra reasoning does not guarantee improvement. Explicit and natural-language triggers, tree-depth syntax, scopes, and CLI modes are precisely distinguished. Environment fit is strong through Unix and Windows shell guidance, PATH resolution, Node 16+ support, three-platform CI, working-directory controls, and configurable shells.

4Convention15 / 18 · 4.2/5

The quick start, repository map, security boundary, gate contract, orchestration guidance, and research basis form a clear information architecture. Installation methods, manual locations, invocation forms, and prerequisites are comprehensive, while product, version, option, and file-layout naming is stable. Examples are extensive, but there is no dedicated FAQ or systematic troubleshooting section, so examples_and_faq is not full. Limitations are disclosed thoroughly and the complete MIT license is present. Version status candidly identifies 2.1.0 as unreleased and points to a changelog, but the changelog itself is absent from the supplied evidence and cannot be assessed. Contribution and vulnerability-reporting routes exist, yet no verified maintainer identity, maintenance commitment, response policy, or stable private security contact is shown, leaving maintenance responsibility thin.

5Effectiveness10 / 13 · 3.8/5

Acceptance ledgers, explicit CHECK/EXPECT/CWD fields, reviewable evidence, and parent-level reruns create directly usable and transferable outputs. Exact approvals, fail-closed checks, ownership coordination, and verification hierarchy offer plausible marginal value over an instruction-only anti-laziness prompt. However, the repository explicitly says the raw artifacts for its earlier internal comparison are unavailable and makes no reproducible fixed-improvement claim, preventing full marginal-value credit. It discusses depth, sequential defaults, opt-in concurrency, verification effort, and attention costs, but does not quantify time, token, or human-review costs against demonstrated gains, so the cost-benefit case remains adequate rather than complete.

6Verifiability7 / 8 · 4.4/5

Behavioral claims are tied to concrete commands, files, states, evidence fields, CI configurations, and dated research references, providing strong traceability. Multiple independent sources corroborate the motivating problems of underthinking, premature completion, and overthinking, but they do not directly validate unlazy's effectiveness; the missing raw artifacts for the historical internal comparison further limit cross-source corroboration. Fact and inference are carefully separated: the documentation states that research does not prove fixed improvement, historical results are not benchmark guarantees, approval does not establish semantic correctness, and stored evidence is not re-execution.

Evidence confidence: Low Reviewed Aug 23, 2026 Reviewed revision 754d9a68109e
The upstream repository has new commits since this review. The score still applies to the reviewed revision shown and may not cover the latest changes.
Before you use it
  • CHECK lines are arbitrary shell code running with the current user's permissions; approval is not a sandbox, so every command, called script, working directory, shell, and PATH must be reviewed before inherited ledgers are run.
  • Commands may read credentials, access networks, and modify data inside or outside the repository; use operating-system, container, or virtual-machine isolation for untrusted sources.
  • Ledger evidence can persist private paths or sensitive output; inspect GATES.md, status logs, and Claude settings before committing or sharing them.
  • Exact approval does not snapshot scripts or executables invoked by the approved command; review those dependencies again when they change even if the CHECK text remains identical.
  • The supplied material describes 2.1.0 as an untagged release; pin the stated commit when immutable installation is required.
  • The cited research supports the motivating failure modes but does not demonstrate a stable or quantified quality improvement from Depth Tree or unlazy itself.
Review evidence [1][2][3][4][5]
See the full review method →

What does this agent do, and when should you use it?

Unlazy is a skill and local command-line checker for substantial AI-agent work, built around layered task decomposition and evidence-backed acceptance ledgers. Its repository contains SKILL.md, planning and gate templates, orchestration references, a Node.js gate checker, an optional Claude Code Stop-hook installer, and regression tests. Users describe outcomes in a Markdown GATES.md file with CHECK commands, EXPECT assertions, working directories, and recorded evidence; gate-check.mjs executes or reverifies those declarations. Multi-agent pipelines can keep plans, leaf ledgers, and branch ledgers under `.unlazy/<scope>/`, using states, declared path ownership, and leases for rolling dispatch. It is installed locally as a skill and explicitly documents Claude Code and Codex CLI usage; executed checks inherit the launching process's filesystem, environment, credentials, and network access. The repository is MIT-licensed, and its source targets version 2.1.0 without claiming that version as a tagged GitHub release.

The workflow begins with an acceptance ledger: each GATES.md entry supplies a CHECK, EXPECT, optional CWD, and EVIDENCE. node <path-to-skill>/scripts/gate-check.mjs --status GATES.md parses and reports status without execution; when a normal run encounters an oracle with no exact approval record, it prints the resolved command, expectation, working directory, shell, and PATH instead of executing it. After reviewing every command and called script, the operator uses --approve to approve and run the ledger. A runnable gate passes only when its process exits 0 and its combined output matches EXPECT, after which evidence records the resolved shell and directory, exit status, a PATH fingerprint, and decisive output. --reverify reruns every runnable gate rather than accepting old evidence. For parallel work, a driver defines interfaces, dependencies, conventions, and OWNS paths under .unlazy/<scope>/, claims leaf leases with --claim, and dispatches work through states such as READY, IN-FLIGHT, and VERIFIED; optional --jobs <N> enables independent checks to run concurrently. The optional Claude Code Stop hook blocks session completion while gates remain unmet but does not execute checks itself.

  1. An engineer leading a large refactor who wants migration paths, tests, and acceptance conditions written down before an agent can report completion.
  2. A solo Claude Code or Codex CLI user who needs long-running work to finish with reproducible command evidence.
  3. A technical lead coordinating several agents in one repository who needs scoped ledgers, declared file ownership, and conservative leases.
  4. A team maintaining CI or regression checks that wants both a zero exit code and an explicit success marker before accepting a result.
  5. A reviewer receiving delegated agent work who wants to rerun every gate instead of trusting completion checkboxes or stale evidence.

What are this agent's strengths and limitations?

Pros
  • Uses a fail-closed rule requiring both exit code 0 and an EXPECT match, rather than treating process success alone as completion.
  • Approval records bind the absolute ledger path, gate, exact command and expectation, CWD, shell, limits, platform, and full PATH; changing a bound input requires new approval.
  • Provides --reverify to rerun completed gates and clearly separates current execution from previously recorded evidence.
  • Includes scoped ledgers, leaf states, path ownership, and leases for dependency-aware rolling orchestration.
  • The checker and optional hook support Node.js 16 and require no third-party runtime packages.
Limitations
  • Approval is not a sandbox: CHECK commands inherit ambient filesystem, environment, credential, and network access, so imported ledgers require manual security review.
  • The checker proves only the declared command oracle and cannot determine whether an English acceptance title genuinely corresponds to arbitrary shell code.
  • Shell and PATH differences can break reverification, particularly when moving between Git Bash and PowerShell on Windows.
  • Leases coordinate cooperating processes but do not isolate writes; colliding output may still require separate worktrees and cache directories.
  • The cited research motivates the targeted failure modes but does not establish a fixed improvement from Unlazy, and the earlier internal comparison lacks reproducible raw artifacts.
  • The documented 2.1.0 state is unreleased source rather than a named GitHub release, so adopters needing immutability must pin an exact commit.

How do you install or deploy this agent?

Install Node.js 16 or newer; the checker and optional hook have no third-party runtime packages. For supported agents, run npx skills add Leonxlnx/unlazy. Add -g for a user-level installation or --all for every detected agent. For manual installation, clone the repository into ~/.claude/skills/unlazy for Claude Code or ~/.codex/skills/unlazy for Codex CLI. No API keys or other credentials are documented as requirements; obtaining the package through npx or Git requires the corresponding network access.

How do you use this agent?

In environments with slash skills, start with /unlazy tree 5 refactor the payment module and verify every migration path; in Codex, invoke $unlazy, or use a natural-language trigger matching the skill description. For solo work, copy templates/gates-leaf.md to GATES.md, replace every placeholder, and inspect it without execution using node <path-to-skill>/scripts/gate-check.mjs --status GATES.md. After reviewing each CHECK and every script it calls, approve and execute the ledger with node <path-to-skill>/scripts/gate-check.mjs --approve GATES.md. To confirm that all results remain valid, run node <path-to-skill>/scripts/gate-check.mjs --reverify GATES.md. The repository's complete test command is npm test.

FAQ

Does Unlazy require a paid service or API key?
No paid service or mandatory API credential is documented. The core checker and optional hook need Node.js 16 or newer and have no third-party runtime dependencies.
Is it safe to run inherited gate files?
Treat them as executable code. CHECK entries run through a shell with ambient filesystem, environment, credential, and network access; the approval record confirms an exact configuration but does not sandbox it.
Will a normal run execute an unreviewed command?
For a new oracle without an exact approval record, normal mode prints the resolved command, expectation, CWD, shell, and PATH without executing. Normal mode is not a permanent dry run, however: it can execute after approval. --status is the only mode documented as always non-executing.
Can it guarantee that the real business outcome was achieved?
No. It verifies the exit status and expected output of the declared command oracle, but it cannot prove that the command faithfully represents the natural-language objective. Consequential manual outcomes still need proportionate review evidence.
Is it suitable for parallel agent work?
Yes, when explicit coordination is useful: it supplies scoped pipelines, states, OWNS declarations, leases, and rolling dispatch. Leases are not write isolation, so conflicting build output or caches may still need separate worktrees or configuration.

Compare agents like this one

The same FARS review applied across the shortlist this agent qualifies for.

Related agents