Autonomous Loops

Supplementary Files:

• payloads.md — Scope Lock templates, rate limit configurations, loop command templates, and error handling response templates
• test-cases.md — Structured test cases for sequential pipeline, watch loop, batch processing, learning cycle, scope violation, and rate limit backoff
• guides/safe-autonomous-pentest.md — Deep-dive guide on autonomous vs manual decision making, scope lock construction, loop composition, and monitoring

Summary

Autonomous Loops skill domain covering infrastructure operations.

Domain: infrastructure

Use Cases

1. Sequential Pipeline — Chain multiple security tools in order (recon → scan → exploit) with automatic phase transitions
2. Watch Loop — Monitor a target for changes (new ports, updated services) over extended periods
3. Batch Processing — Run the same test against multiple targets with rate limiting and error recovery
4. Learning Cycle — Execute a skill, capture results, extract patterns, and update knowledge base automatically
5. Scope-Locked Automation — Run autonomous loops with hard boundaries that prevent actions outside authorized scope

Activation

• Performing repetitive enumeration across many targets
• Running batch vulnerability scans on multiple hosts
• Monitoring for changes in target environment
• Executing attack chains that require iterative steps
• User says "loop", "automate", "batch", "repeat", "iterate"

Core Principle

Autonomous does not mean uncontrolled. Every loop must have:

1. A defined scope (what it can and cannot touch)
2. A termination condition (when it stops)
3. Rate limiting (how fast it runs)
4. Evidence logging (what it did)
5. Error handling (what happens when things go wrong)

Four Loop Patterns

Pattern 1: Sequential Pipeline

Execute a sequence of steps across multiple targets, one at a time.

FOR EACH target IN target_list:
    IF scope_check(target) == ALLOWED:
        result = execute_step(target)
        log_evidence(target, result)
        IF result.status == FAIL:
            handle_error(target, result)
            CONTINUE or BREAK based on severity
    ELSE:
        log_skipped(target, "Out of scope")

Use when: Enumerating ports across a subnet, testing a specific vulnerability across multiple hosts.

Safety rules:

• Process targets sequentially (no parallel burst)
• Log every target attempted and result
• Stop on critical error (target down, IDS triggered)
• Maximum 100 targets per pipeline run

Pattern 2: Watch Loop

Monitor a target for changes or conditions, then act when triggered.

WHILE condition_not_met AND iterations < max_iterations:
    current_state = observe(target)
    log_observation(current_state)
    IF trigger_condition(current_state):
        result = execute_response(target, current_state)
        log_evidence("trigger", result)
        IF one_shot: BREAK
    WAIT(polling_interval)

Use when: Waiting for a service to come online, monitoring for new open ports, watching log files for specific events.

Safety rules:

• Polling interval minimum: 5 seconds
• Maximum iterations: 1000
• Log every observation cycle
• Alert when approaching iteration limit

Pattern 3: Batch Processing

Apply the same operation to a batch of targets in parallel (with concurrency limit).

CONCURRENCY = 5  # Maximum simultaneous operations
results = []

FOR EACH batch IN split_into_batches(target_list, CONCURRENCY):
    batch_results = PARALLEL execute_step(batch)
    FOR EACH result IN batch_results:
        log_evidence(result.target, result)
        results.append(result)
    WAIT(rate_limit_delay)  # Pause between batches

Use when: Running nmap scans across many hosts, batch DNS lookups, mass HTTP header checks.

Safety rules:

• Maximum concurrency: 10
• Rate limit delay between batches: 2 seconds minimum
• Log all results including failures
• Respect target-specific rate limits if known

Pattern 4: Learning Cycle

Iteratively refine an approach based on results from previous iterations.

approach = initial_approach
FOR iteration IN range(max_iterations):
    result = execute(approach)
    analysis = analyze_result(result)
    log_evidence(iteration, approach, result, analysis)
    IF analysis.success:
        log_evidence("success", approach)
        BREAK
    approach = refine(approach, analysis)
    IF approach.confidence < min_confidence:
        log_evidence("abort", "Confidence below threshold")
        BREAK

Use when: Brute-forcing with adaptive wordlists, SQL injection payload refinement, fuzzing with feedback.

Safety rules:

• Maximum iterations: 50
• Log every attempt and result
• Confidence threshold: abort if below 10% after 10 attempts
• Never widen scope during refinement

Safety Framework

Scope Lock

Before ANY loop starts, define and lock the scope:

## Scope Lock: [Operation Name]
- **Allowed targets:** [CIDR range / hostname list / URL list]
- **Allowed operations:** [Specific commands/techniques]
- **Forbidden operations:** [What must NOT be done]
- **Time limit:** [Maximum wall-clock time]
- **Iteration limit:** [Maximum number of iterations]
- **Abort conditions:** [Specific triggers that stop the loop]

Once defined, the scope cannot be widened during execution.

Rate Limiting

Operation Type	Minimum Interval	Max Concurrency
Network scan (nmap)	2s between hosts	5
Web request (HTTP)	100ms between requests	3
DNS lookup	50ms between queries	10
Brute force attempt	500ms between attempts	1
Exploit attempt	5s between attempts	1

Evidence Logging

Every loop iteration must log:

## Loop Log Entry
- **Timestamp:** [ISO 8601]
- **Iteration:** [N / max]
- **Target:** [host/port/URL]
- **Action:** [command or technique]
- **Result:** [success/fail/error/timeout]
- **Output:** [truncated to 500 chars, full output saved to file]
- **State change:** [what changed on target, if any]

Error Handling

Error Type	Response
Target unreachable	Log and skip, continue to next target
Rate limit detected	Increase delay by 2x, retry once
Authentication failure	Log and skip (do NOT retry with variations)
Unexpected service response	Log details, flag for manual review, continue
IDS/IPS detected	STOP immediately, log incident
Target crash/unexpected downtime	STOP immediately, log incident
Scope violation attempt	STOP immediately, log incident

Notification Rules

Notify the operator when:

• Loop starts (with scope summary)
• Every 25 iterations or 5 minutes (whichever comes first)
• Any error condition occurs
• Loop completes or aborts

Integration with Other Skills

Skill	Loop Pattern	Application
vulnerability-assessment	Batch Processing	Scan multiple hosts for vulnerabilities
password-attack	Learning Cycle	Adaptive brute force with feedback
web-sqli	Learning Cycle	Iterative payload refinement
network-pentest	Sequential Pipeline	Multi-host enumeration
osint	Batch Processing	Mass DNS/WHOIS lookups
terminal-ops	All patterns	Evidence logging protocol
verification-loop	Sequential Pipeline	Verify findings across multiple hosts
safety-guard	All patterns	Pre-execution safety checks

Detection Methods

Autonomous Loop Indicators

• Sustained agent activity: Same agent token executing >100 sequential operations; >24h continuous runtime.
• Tool call cadence: Constant-interval tool calls (e.g., every 30s exactly); typical of cron-driven loops.
• State persistence: Agent re-loading state from previous session; checkpoint file access patterns.
• Memory growth: Agent process accumulating >2GB RAM; typical of long-running loops without state cleanup.
• Self-modifying prompts: Agent modifying its own system prompt or configuration mid-run.

SIEM Detection Rules

• Splunk SPL: index=llm gateway.user="agent-*" | stats range(_time) as duration by session_id | where duration > 86400
• Sigma rule: sigma/rules/ai/long_running_agent.yml
• LangSmith trace analysis: Detect agents with >1000 turns in single session.

Defense Evasion Techniques

Loop Stealth

• Off-hours operation: Run loops during low-traffic hours; blends with maintenance tasks.
• Distributed sessions: Cycle through multiple agent sessions to avoid per-session limits.
• Memory cleanup between cycles: Clear conversation history to reduce token usage anomaly.
• Slow pacing: Pace tool calls at irregular intervals to avoid cadence detection.
• State externalization: Store state in external KV store rather than session memory.

Self-Modification Stealth

• Gradual config changes: Modify system prompt in small increments over multiple sessions.
• Use environment variables: Modify env vars rather than prompts (less audited).
• Persistence via legitimate mechanisms: Use MCP server registration (looks legitimate).

Anti-Patterns

• Infinite loops — Every loop MUST have a termination condition
• Scope creep — Never add targets during execution
• Silent failures — Every error must be logged and reported
• Unbounded parallelism — Always set and respect concurrency limits
• Skipping evidence — Even failed attempts must be logged
• Ignoring rate limits — Target stability is more important than speed

Orchestration

ECC Loop Pattern

• Pattern: Meta-Skill (defines loop patterns consumed by all other skills)
• Rationale: Autonomous loops is not an end-user skill but a meta-skill that provides loop constructs for all other security skills — every skill that needs iterative or batch operations consumes one of the four loop patterns
• Integration: All security skills that need repetitive operations consume loop patterns from this skill. Each skill selects the appropriate pattern based on its workflow needs.

Cross-Skill Pipeline

autonomous-loops (provides loop patterns)
    ├── Sequential Pipeline → network-pentest, terminal-ops, verification-loop
    ├── Watch Loop → security-bounty-hunter, deep-research
    ├── Batch Processing → repo-scan, osint, vulnerability-assessment
    └── Learning Cycle → search-first, continuous-learning, password-attack

Quality Gate

• Pre-condition: Scope Lock defined with allowed targets, operations, and abort conditions
• Post-condition: Evidence chain complete for every iteration, all results logged
• Verification: Scope not widened during execution, iteration/iteration limits respected, rate limits maintained