God Mode , Autonomous AI Agent Loop

intent

this skill transforms any openclaw agent into a continuously executing autonomous worker that wakes on heartbeat cycles, reads a priority task queue, executes the highest-priority item, logs and audits results, and self-cleans its workspace. use this when you want your agent to work without waiting for user input, with full audit trails and guardrails against runaway execution.

inputs

external connections:

• openclaw heartbeat system (built-in, configured in openclaw config with 30-minute cycle recommended)
• workspace filesystem access (read/write to task queue and memory files)

workspace files required:

• TASKS.md (priority task queue, markdown format, agent-readable)
• memory/god-mode-state.json (state tracking between cycles, json format)
• HEARTBEAT.md (cycle behavior specification, markdown format)
• memory/YYYY-MM-DD.md (daily execution log, created auto on first cycle)

permissions needed:

• read/write access to workspace root
• ability to create and archive files in memory/ and memory/archive/
• ability to read all available agent tools (whatever the agent session supports)

optional configurations:

• quiet hours (time range when agent only monitors, does not execute)
• max consecutive error threshold (default: 3, triggers pause-and-alert)
• hygiene sweep interval (default: every 12 cycles, roughly hourly at 5-min heartbeats)
• stale file threshold (default: 7 days)

procedure

1. heartbeat received → openclaw sends heartbeat message to agent session, triggering god mode startup.

   • input: heartbeat signal from openclaw
   • output: god mode begins cycle

2. load cycle state → agent reads god-mode-state.json from disk.

   • input: memory/god-mode-state.json
   • output: in-memory state object with lastCycle, cycleCount, lastTask, lastResult, errors, consecutiveErrors, totalTasksCompleted

3. check error circuit breaker → if consecutiveErrors >= 3, log warning, skip task execution, alert human via logs, proceed only to state update and sleep.

   • input: state.consecutiveErrors
   • output: either continue to step 4 or jump to step 9

4. check quiet hours → if current time falls in configured quiet hours window, skip task execution, log monitoring event, jump to step 9.

   • input: current time, quiet hours config
   • output: either continue to step 5 or jump to step 9

5. read task queue → agent reads TASKS.md, scans for first uncompleted task (unmarked checkbox [ ] not [x]).

   • input: TASKS.md
   • output: task object with description, context, priority level, or null if no tasks remain

6. execute task → agent uses available tools to complete the task described in step 5. execution runs with timeout (recommend 5-10 min per task, configurable).

   • input: task object, available agent tools, workspace context
   • output: result object with success boolean, result summary string, errors if any, execution time in seconds

7. append to daily log → agent appends execution record to memory/YYYY-MM-DD.md (today's date, created if missing). format: timestamp, task name, result, execution time, any errors.

   • input: result object from step 6, current date
   • output: memory/YYYY-MM-DD.md updated with new line

8. self-audit and update state → agent writes one audit line to daily log (e.g., "cycle productive: yes, task completed successfully"). agent increments cycleCount, records lastTask, lastResult, updates lastCycle timestamp. if result.success = true, reset consecutiveErrors to 0, increment totalTasksCompleted; if result.success = false, increment both errors and consecutiveErrors.

   • input: result.success, previous state
   • output: god-mode-state.json updated on disk

9. mark task complete in queue → if step 6 succeeded, agent marks checkbox [x] in TASKS.md. if any new subtasks were discovered during execution, agent appends them to TASKS.md under appropriate priority.

   • input: task name, result.success
   • output: TASKS.md updated

10. check if hygiene cycle → if cycleCount mod 12 = 0, run workspace hygiene (step 11). else skip to step 12.

    • input: cycleCount
    • output: either continue to step 11 or skip to step 12

11. run workspace hygiene → agent scans workspace following rules in "self-cleaning" section below. moves stale files to memory/archive/, compresses if needed, logs all actions.

    • input: workspace filesystem, stale file threshold config
    • output: cleaned workspace, hygiene log appended to daily log

12. sleep until next heartbeat → agent goes idle, waiting for next heartbeat signal from openclaw.

    • input: configured heartbeat interval
    • output: agent waits, no further action until next heartbeat

decision points

error circuit breaker: if consecutiveErrors >= 3, skip task execution (step 6 and 9), log warning alert, proceed to state update and sleep. this prevents runaway failure loops. human must manually reset consecutiveErrors in god-mode-state.json to 0 to resume autonomy.

quiet hours: if current time falls within configured quiet hours (e.g., 10pm to 6am), skip task execution and logging, only perform state monitoring. this respects human sleep schedules and defined agent downtime. if no quiet hours configured, agent runs 24/7.

red-line task detection: if task description contains any of these keywords (money, payment, contract, delete, fire, irreversible, critical infrastructure), agent logs task but does not execute. instead, agent appends flag [HUMAN-APPROVAL-REQUIRED] to task in TASKS.md and alerts human via logs. human must manually approve by adding [APPROVED] flag before agent will execute.

task queue empty: if no uncompleted tasks found in TASKS.md, agent logs "queue empty" to daily log, does not increment totalTasksCompleted, resets consecutiveErrors to 0, and proceeds to sleep. this is normal, not an error.

execution timeout: if task execution exceeds configured timeout (default 5-10 min), agent terminates execution, logs timeout error, marks task as failed, increments consecutiveErrors, and proceeds to state update and sleep.

workspace hygiene: if cycleCount mod 12 = 0, run hygiene sweep. else skip. this keeps workspace lean on a schedule. if workspace is under 100MB and has no files > 7 days old, hygiene sweep logs "workspace clean" and exits early.

output contract

success looks like:

1. god-mode-state.json updated after every cycle with:

   • lastCycle: ISO 8601 timestamp of this cycle
   • cycleCount: incremented by 1
   • lastTask: name of task just attempted
   • lastResult: "success" or "failure"
   • errors: total error count
   • consecutiveErrors: 0 if last task succeeded, else +1
   • totalTasksCompleted: incremented only if lastResult = "success"

2. memory/YYYY-MM-DD.md appended with one line per cycle:

   • format: HH:MM:SS | task name | success/failure | execution time (s) | error details (if any) | audit note
   • example: 14:22:45 | Check Moltbook engagement | success | 28 | none | cycle productive: yes, engaged 12 users

3. TASKS.md updated:

   • completed task marked [x] and moved to "Completed" section with result summary and timestamp
   • any discovered subtasks appended to appropriate priority section
   • red-line tasks flagged [HUMAN-APPROVAL-REQUIRED] if detected

4. memory/archive/ created and populated if hygiene cycle runs:

   • stale files (> 7 days old) moved here with original directory structure preserved
   • compressed to .tar.gz if archive > 10MB
   • log entry appended to daily log documenting all moves

data formats are strictly yaml/json/markdown, human and machine readable. no binary formats. all timestamps in iso 8601 UTC.

outcome signal

the user knows the skill worked when:

1. daily log appears → memory/YYYY-MM-DD.md exists and contains timestamped entries, one per heartbeat cycle, showing tasks attempted and results.

2. state file updates → god-mode-state.json cycleCount increments on each heartbeat, lastCycle timestamp moves forward, totalTasksCompleted increases when tasks succeed.

3. tasks get marked done → items in TASKS.md marked [x] when completed, moved to "Completed" section with timestamp, proving execution happened.

4. no manual intervention needed → once configured, agent runs autonomously, no user needs to prompt it or check on it between heartbeats. work happens on schedule.

5. audit trail is complete → every action logged with timestamp, task name, result, execution time, errors if any. audit trail is append-only, immutable, and reviewable.

6. workspace stays clean → on hygiene cycles, stale files moved to archive, no junk accumulates in workspace root, memory/archive/ grows as logs age.

7. guardrails fire on red-line tasks → if task contains "money", "contract", "delete", etc., agent does not execute, instead flags it for human approval in logs and TASKS.md.

8. consecutive errors trigger pause → if 3+ tasks fail in a row, agent logs alert and stops executing new tasks, waiting for human to investigate and reset the error counter.

if god mode is broken, none of these signals appear. daily log stays empty. state file does not update. TASKS.md does not change. workspace gets messy. no audit trail.