autonomous-loops
Patterns and architectures for autonomous OpenAI Codex loops — from simple sequential pipelines to RFC-driven multi-agent DAG systems.
npx skills add mturac/everything-openai-codex --skill autonomous-loops --agent codex
Same command for any agent — swap --agent for claude-code, cursor, copilot.
Weekly change comes from our own snapshots, not the repository page — it measures attention, not adoption.
What it does
Provides patterns, architectures, and reference implementations for running OpenAI Codex autonomously in loops, ranging from simple sequential pipelines to RFC-driven multi-agent DAG orchestration. It also documents variations, tooling, and usage contexts for autonomous development workflows.
How it works
Describes multiple loop patterns and concrete prompts:
- Sequential Pipeline: demonstrates chaining codex -p calls with explicit prompts for steps like feature implementation, cleanup, verification, and commit.
- NanoClaw REPL: explains a session-based, persistent interaction with codex -p, loading history from a local file, and appending responses.
- Infinite Agentic Loop: outlines a two-prompt orchestrator/sub-agent system, where an orchestrator parses a spec, assigns unique directions to N agents, and deploys in waves until context is exhausted.
- Continuous Codex PR Loop: details a production loop that creates branches, runs codex -p, optionally adds a reviewer pass, creates PRs, waits for CI, auto-fixes on CI failures, and merges.
- De-Sloppify Pattern: adds a separate cleanup pass after Implementer step to remove non-business-logic tests and redundant checks, keeping business logic tests intact.
- Ralphinho / RFC-Driven DAG Orchestration: describes RFC-driven decomposition into work units forming a dependency DAG, a multi-pass quality pipeline per unit, and a merge queue for landing units.
The skill provides concrete commands and file references (e.g., codex -p prompts, shell scripts, and code structure) to implement these patterns.
When to use it
Use for setting up autonomous development workflows that run without human intervention, choosing appropriate loop architecture, building CI/CD-like pipelines, running parallel agents with coordination, enabling context persistence across iterations, and adding quality gates and cleanup passes.
What it can touch
The skill references tools and commands such as codex, claw.js (NanoClaw), and various shell scripts for loop orchestration, plus a repository layout with paths like .codex/commands/infinite.md and output directories for iterations. It also mentions creating branches and PR interactions via gh pr commands and related CI workflows.
Caveats
Compatibility note indicates the canonical name moved to continuous-agent-loop for new guidance, while this skill remains for backward compatibility. The content includes examples and patterns but does not guarantee successful automation in all environments or real-world CI interactions. License is MIT as declared.
# Autonomous Loops Skill > Compatibility note (v1.8.0): `autonomous-loops` is retained for one release. > The canonical skill name is now `continuous-agent-loop`. New loop guidance > should be authored there, while this skill remains available to avoid > breaking existing workflows. Patterns, architectures, and reference implementations for running OpenAI Codex autonomously in loops. Covers everything from simple `codex -p` pipelines to full RFC-driven multi-agent DAG orchestration. ## When to Use - Setting up autonomous development workflows that run without human intervention - Choosing the right loop architecture for your problem (simple vs complex) - Building CI/CD-style continuous development pipelines - Running parallel agents with merge coordination - Implementing context persistence across loop iterations - Adding quality gates and cleanup passes to autonomous workflows ## Loop Pattern Spectrum From simplest to most sophisticated: | Pattern | Complexity | Best For | |---------|-----------|----------| | [Sequential Pipeline](#1-sequential-pipeline-codex--p) | Low | Daily dev steps, scripted workflows | | [NanoClaw REPL](#2-nanoclaw-repl) | Low | Interactive persistent sessio
- When to Use
- Loop Pattern Spectrum
- 1. Sequential Pipeline (codex -p)
- Core Insight
- Key Design Principles
- Variations
- 2. NanoClaw REPL
- How It Works
- When NanoClaw vs Sequential Pipeline
- 3. Infinite Agentic Loop
- Architecture: Two-Prompt System
- The Pattern
- Implementation via OpenAI Codex Commands
- Batching Strategy
daily-dev.sh — Sequential pipeline for a feature branch set -e Step 1: Implement the feature codex -p "Read the spec in docs/auth-spec.md. Implement OAuth2 login in src/auth/. Write tests first (TDD). Do NOT create any new documentation files." Step 2: De-sloppify (cleanup pass) Step 3: Verify codex -p "Run the full build, lint, type check, and test suite. Fix any failures. Do not add new features." Step 4: Commit codex -p "Create a conventional commit for all staged changes. Use 'feat: add OAuth2 login flow' as the message." Research with Deep (deep reasoning)
What does the autonomous-loops skill do?
Patterns and architectures for autonomous OpenAI Codex loops — from simple sequential pipelines to RFC-driven multi-agent DAG systems.
How do I install it?
Run `npx skills add mturac/everything-openai-codex --skill autonomous-loops --agent claude-code` — it drops the skill into your project so the agent can pick it up. Swap the --agent value for codex, cursor or copilot if you use one of those.
Where does this skill come from?
From mturac/everything-openai-codex, a repository with 84 stars. We read it straight from the repository tree rather than a submitted listing, so what you see here is what is actually published.
Is a popular skill a good skill?
Not necessarily. Stars measure attention, not adoption — a repository can trend for a week and be abandoned. That is why we show the weekly change from our own snapshots next to the total, instead of a single flattering number.