agent-loop

Automate GitHub issue implementation with isolated worktrees and multi-stage code review.

2|Updated May 10, 2026
One-click install
npx skills add https://github.com/loomantix/codex-platform --skill agent-loop-loomantix
Or copy as Structured Prompt for Agent
Please help me install this Agent Skill.
Skill: agent-loop
Source: https://github.com/loomantix/codex-platform/tree/main/.codex/skills/agent-loop
Command: npx skills add https://github.com/loomantix/codex-platform --skill agent-loop-loomantix

SYSTEM DOCUMENTATION & REQUIREMENTS

💡 This Skill requires git, gh, jq, python3, timeout, and includes scripts (resource) components.

What problem does it solve?

This skill solves the bottleneck of manual issue implementation and review by providing an autonomous, safety-gated loop that handles worktree management, local implementation, and multi-engine code review.

Core Features & Use Cases

  • Autonomous Issue Worker: Automatically claims, implements, and validates GitHub issues within isolated worktrees.
  • Convergent Review: Orchestrates a multi-pass review process using Codex and Claude to ensure code quality before publication.
  • Use Case: Use this skill to manage a high-volume backlog of GitHub issues where you need to ensure every implementation is validated, refactored, and reviewed against strict repository standards without manual intervention.

Quick Start

Use the agent-loop skill to process issues 5105 and 5106 with a maximum of two iterations.

Frequently Asked Questions about agent-loop

High-intent search queries and answers about installing and using this skill.

FAQPage Schema
How do I automate GitHub issue implementation and code review?

You can automate GitHub issue implementation by using an autonomous loop that claims issues, executes work in isolated worktrees, and runs multi-stage adversarial code reviews. This handles the end-to-end lifecycle from implementation to validation without manual intervention.

How does multi-stage code review work for autonomous issue workers?

Multi-stage code review works by orchestrating a convergent, multi-pass review process using Codex and Claude to validate and refactor code against repository standards. It ensures strict dependency gating and inline finding traceability before any code is published.

Do I need git and gh installed to run an autonomous issue implementation loop?

Yes, you need git, gh, jq, python3, and timeout installed. These dependencies are required to manage worktree isolation, execute local workers, handle issue tracking, and enforce bounded convergence during the review process.

Can I process multiple GitHub issues in a single automated workflow run?

Yes, you can process multiple GitHub issues in a single run by specifying the issue numbers and a maximum iteration count. The autonomous worker sequentially claims, implements, and validates each issue within isolated worktrees.

What is worktree isolation in autonomous software engineering workflows?

Worktree isolation is the practice of executing local worker implementations in separate git worktrees. It prevents branch conflicts and ensures that automated code review and validation processes remain non-mutating and independently verifiable.

When should I avoid using an autonomous code review and implementation loop?

You should avoid using an autonomous implementation loop for issues requiring subjective architectural decisions or manual design input. The loop is designed for high-velocity, high-volume backlogs requiring strict dependency gating and bounded convergence, not open-ended design tasks.