Get the FREE Ultimate OpenClaw Setup Guide →

autonomous-skill

npx machina-cli add skill feiskyer/codex-settings/autonomous-skill --openclaw
Files (1)
SKILL.md
9.2 KB

Autonomous Skill - Long-Running Task Execution

Execute complex, long-running tasks across multiple sessions using a dual-agent pattern (Initializer + Executor) with automatic session continuation via Codex non-interactive mode.

Quick Start

Use the run-session.sh script to manage autonomous tasks:

# Start a new autonomous task
~/.codex/skills/autonomous-skill/scripts/run-session.sh "Build a REST API for todo app"

# Continue an existing task
~/.codex/skills/autonomous-skill/scripts/run-session.sh --task-name build-rest-api-todo --continue

# List all tasks and their progress
~/.codex/skills/autonomous-skill/scripts/run-session.sh --list

# Show help
~/.codex/skills/autonomous-skill/scripts/run-session.sh --help

Directory Structure

All task data is stored in .autonomous/<task-name>/ under the project root:

project-root/
└── .autonomous/
    ├── build-rest-api/
    │   ├── task_list.md        # Master task checklist
    │   ├── progress.md         # Session-by-session notes
    │   ├── session.id          # Last Codex session ID for resumption
    │   └── session.log         # JSON Lines output from sessions
    ├── refactor-auth/
    │   ├── task_list.md
    │   ├── progress.md
    │   └── session.id
    └── ...

This allows multiple autonomous tasks to run in parallel without conflicts.

Script Options

Usage:
  run-session.sh "task description"           Start new task (auto-generates name)
  run-session.sh --task-name <name> --continue Continue specific task
  run-session.sh --list                        List all tasks
  run-session.sh --help                        Show help

Options:
  --task-name <name>       Specify task name explicitly
  --continue, -c           Continue existing task
  --no-auto-continue       Don't auto-continue after session
  --max-sessions N         Limit to N sessions
  --list                   List all existing tasks
  --resume-last            Resume the most recent Codex session
  --network                Enable network access (uses danger-full-access sandbox)

Workflow Overview

User Request → Generate Task Name → Create .autonomous/<task-name>/ → Execute Codex Sessions
                                                                            ↓
                                                                    ┌───────────────┐
                                                                    │ task_list.md  │
                                                                    │ exists?       │
                                                                    └───────┬───────┘
                                                                            │
                                                    ┌───────────────────────┴───────────────────────┐
                                                    │ NO                                        YES │
                                                    ▼                                              ▼
                                            ┌───────────────┐                            ┌───────────────┐
                                            │  INITIALIZER  │                            │   EXECUTOR    │
                                            │  - Analyze    │                            │  - Read state │
                                            │  - Break down │                            │  - Next task  │
                                            │  - Create     │                            │  - Implement  │
                                            │    task_list  │                            │  - Mark done  │
                                            └───────────────┘                            └───────────────┘
                                                                            │
                                                                            ▼
                                                                    ┌───────────────┐
                                                                    │ All complete? │
                                                                    └───────┬───────┘
                                                                            │
                                                            ┌───────────────┴───────────────┐
                                                            │ NO                        YES │
                                                            ▼                              ▼
                                                    Auto-continue               Exit with success
                                                    (3 sec delay)

Usage Examples

Example 1: Start New Task

~/.codex/skills/autonomous-skill/scripts/run-session.sh "Build a REST API for todo app"

Output:

ℹ Generated task name: build-rest-api-todo
==========================================
  SESSION 1 - build-rest-api-todo
==========================================

==========================================
  INITIALIZER SESSION
==========================================
Task: Build a REST API for todo app
Task Name: build-rest-api-todo
Task Directory: .autonomous/build-rest-api-todo

[Codex creates task_list.md with 25 tasks...]

✓ Initializer session complete
ℹ Session ID saved: 550e8400-e29b-41d4-a716-446655440000

=== Progress: 0/25 ===

Continuing in 3 seconds... (Press Ctrl+C to pause)

Example 2: Continue Existing Task

~/.codex/skills/autonomous-skill/scripts/run-session.sh --task-name build-rest-api-todo --continue

Example 3: Resume with Session Context

# Resume the Codex session (preserves conversation context)
~/.codex/skills/autonomous-skill/scripts/run-session.sh --task-name build-rest-api-todo --continue --resume-last

Example 4: List All Tasks

~/.codex/skills/autonomous-skill/scripts/run-session.sh --list

Output:

==========================================
  AUTONOMOUS TASKS
==========================================
  ✓ build-rest-api-todo (25/25 - 100% complete) [session: 550e8400...]
  ○ refactor-auth (12/30 - 40%) [session: 661f9511...]
  ? incomplete-task (no task_list.md)

Example 5: With Network Access

# Enable network access for tasks that need API calls
~/.codex/skills/autonomous-skill/scripts/run-session.sh --network "Fetch data from GitHub API and analyze"

Key Files

For each task in .autonomous/<task-name>/:

FilePurpose
task_list.mdMaster task list with checkbox progress
progress.mdSession-by-session progress notes
session.idLast Codex session ID for resumption
session.logJSON Lines output from Codex sessions

Important Notes

  1. Task Isolation: Each task has its own directory, no conflicts
  2. Task Naming: Auto-generated from description (lowercase, hyphens, max 30 chars)
  3. Task List is Sacred: Never delete or modify task descriptions, only mark [x]
  4. One Task at a Time per Session: Focus on completing tasks thoroughly
  5. Auto-Continue: Sessions auto-continue with 3s delay; Ctrl+C to pause
  6. Session Resumption: Use --resume-last to preserve Codex conversation context
  7. Network Mode: --network uses --dangerously-bypass-approvals-and-sandbox; only use in an isolated environment
  8. Git Hygiene: Consider adding .autonomous/ to .gitignore to avoid committing logs

Codex CLI Reference

The script uses these Codex commands internally:

# Non-interactive execution with file edits (fully autonomous)
# --full-auto: autonomous execution with workspace-write sandbox
codex exec --full-auto --json "prompt"

# Resume previous session
codex exec --full-auto --json resume <SESSION_ID> "prompt"

# Full access (file edits + network) - use with caution!
codex exec --dangerously-bypass-approvals-and-sandbox --json "prompt"

Troubleshooting

IssueSolution
Task not foundRun --list to see existing tasks
Multiple tasksSpecify task name with --task-name
Session stuckCheck session.log in task directory
Need to restartDelete task directory and start fresh
Resume failedRemove session.id to start fresh session
Codex not foundInstall Codex CLI: npm install -g @openai/codex

Source

git clone https://github.com/feiskyer/codex-settings/blob/main/skills/autonomous-skill/SKILL.mdView on GitHub

Overview

Autonomous-skill orchestrates long-running tasks across multiple Codex sessions using a dual-agent pattern (Initializer + Executor) with automatic session continuation. It decomposes work, tracks progress in a master task_list.md, and stores session details in per-task folders to run tasks in parallel without conflicts.

How This Skill Works

Tasks are managed under .autonomous/<task-name>/ with a master task_list.md and per-session progress in progress.md. The workflow uses an INITIALIZER to analyze and break down the task, and an EXECUTOR to read state and perform the next steps, with Codex non-interactive mode enabling auto-continuation and resumption via session.id.

When to Use It

  • You need to execute a long-running task that requires multiple Codex sessions to complete.
  • You want to run multiple autonomous tasks in parallel without conflicts.
  • You require automatic session continuation to avoid manual intervention.
  • You need a persistent, session-by-session record of progress for complex tasks.
  • You want to easily resume, monitor, and manage ongoing tasks using a simple CLI.

Quick Start

  1. Step 1: Start a new task with run-session.sh "Build a REST API for todo app"
  2. Step 2: Continue an existing task with run-session.sh --task-name build-rest-api-todo --continue
  3. Step 3: List all tasks with run-session.sh --list

Best Practices

  • Define a clear, descriptive task name to map to .autonomous/<task-name>/ and avoid naming collisions.
  • Regularly check progress.md and task_list.md to ensure the task state accurately reflects progress.
  • Use --continue (or -c) to resume a specific task and --list to monitor all tasks.
  • Limit concurrent tasks if resources are constrained to prevent conflicts.
  • Document task scope and checkpoints within task_list.md to guide the INITIALIZER and EXECUTOR.

Example Use Cases

  • Build a REST API for a todo app using a multi-session approach.
  • Refactor authentication flow in a web application across sessions.
  • Implement a multi-stage data migration task with incremental checkpoints.
  • Create a modular microservice skeleton for a new feature across tasks.
  • Run parallel autonomous tasks for separate feature branches without interference.

Frequently Asked Questions

Add this skill to your agents
Sponsor this space

Reach thousands of developers ↗