DEV Community: autodrive-cyber

How I Built an Idle Loop That Keeps My AI Agent Working Between Tasks

autodrive-cyber — Wed, 22 Apr 2026 15:52:47 +0000

The Problem

My AI agent was idle 90% of the time.

Between my requests, it just sat there. GPU loaded, API connections open, doing absolutely nothing. That felt like leaving a factory running with no production line active.

So I built a lightweight idle loop. Here's exactly how.

The Architecture (3 Components)

1. Plan-Tree with Timestamps

A markdown file that tracks every task with last-run timestamps:

## ENSURE_CONTINUATION [last: 2026-04-23 01:00 | 🔁]
- Health checks (disk/RAM/process) [last: 2026-04-23 01:00 | ✅]
- Backup verification [last: 2026-04-23 01:00 | ✅]

## EXPAND_CAPABILITIES [last: 2026-04-22 22:30 | 🔁]
- Skill audit and patch [last: - | ⏳]
- Pattern crystallization [last: - | ⏳]

## EXPAND_WORLD_MODEL [last: 2026-04-23 01:00 | 🔁]
- GitHub scan for relevant repos [last: 2026-04-23 01:00 | ✅]
- arXiv scan for relevant papers [last: - | ⏳]

Every item knows when it was last executed. The loop skips fresh items and works on stale ones.

2. Cron-Triggered Idle Loop

Every 15 minutes, a lightweight process scans the plan-tree:

# Lock mechanism — don't interfere with active user tasks
if [ -f ~/.hermes/agent-busy.lock ]; then
    # User is chatting — just scan and queue
    scan_plan_tree > ~/.hermes/pending-tasks.md
else
    # User is away — execute idle tasks
    acquire_lock "idle-loop"
    execute_idle_tasks
    release_lock
fi

The three-priority system:

ENSURE_CONTINUATION — health checks, backups, service monitoring
EXPAND_CAPABILITIES — distill patterns into reusable skills, patch broken ones
EXPAND_WORLD_MODEL — scan GitHub/arXiv, update knowledge base

3. Busy-Lock Mechanism

This is the critical safety layer. Without it, the idle loop would conflict with user tasks.

# Lock file format: timestamp:reason
# Example: 1745384400:conversation  (user is chatting)
# Example: 1745384400:idle-loop     (agent is self-improving)

acquire_lock() {
    echo "$(date +%s):$1" > ~/.hermes/agent-busy.lock
}

release_lock() {
    rm -f ~/.hermes/agent-busy.lock
}

check_lock() {
    if [ -f ~/.hermes/agent-busy.lock ]; then
        local ts=$(cut -d: -f1 ~/.hermes/agent-busy.lock)
        local now=$(date +%s)
        local age=$(( now - ts ))
        if [ $age -gt 600 ]; then  # 10 min timeout
            release_lock  # stale lock
            return 1
        fi
        return 0  # active lock
    fi
    return 1  # no lock
}

User always wins. When a user message arrives, the agent:

Finishes the current sub-task (no half-writes)
Saves remaining tasks to pending-tasks.md
Releases the idle-lock
Switches to the user's task

What Happens When the User Is Away

After 10 minutes of inactivity, the lock expires. The next cron trigger:

Checks system health (disk, RAM, processes)
Verifies backups exist and aren't stale
Scans GitHub for repos relevant to active projects
Searches arXiv for recent papers
Updates the knowledge wiki with findings
Audits skills — patches failures, crystallizes patterns
Writes everything to idle-log.md with timestamps

All of this happens autonomously. The next time the user returns, they find:

An updated knowledge base
Fixed skills
A summary of what happened (in pending-tasks.md)

Wiki Offload for Efficiency

When a plan branch becomes inactive, it gets "folded" into the wiki:

## 🔁 Drive Loops (auto-maintained, folded to wiki)
### ENSURE_CONTINUATION → wiki:plan-ENSURE-CONTINUATION [last: 2026-04-22 | 🔁]
### EXPAND_CAPABILITIES → wiki:plan-EXPAND-CAPABILITIES [last: 2026-04-22 | 🔁]

The full sub-tree lives in wiki/plan-ENSURE-CONTINUATION.md. When the branch becomes active again, it unfolds back into the plan-tree.

This keeps the plan-tree small (under 100 lines) while preserving full depth in the wiki.

Results After 48 Hours

Metric	Value
Automatic backups created	8
Relevant GitHub repos discovered	12
arXiv papers found	3
Skills patched	1
Embedding bug caught	1
Idle time utilized	~90% (was 0%)

The Full Implementation

Available as an open-source skill: github.com/autopopo-cyber/autonomous-drive-spec

Works with Hermes Agent. The philosophy (why a survival drive makes sense) is in ORIGIN.md.

Key Takeaways

Timestamps enable smart scheduling — skip fresh items, work on stale ones
Busy-locks prevent conflicts — user tasks always preempt idle work
Wiki offload keeps plan-tree lean — full depth preserved, working set small
The loop should be lightweight — cron triggers a scanner, not a full agent session
Separate scanning from execution — scanning is safe and fast; execution is heavy and needs locks

What would you add to an idle loop? What would you want your agent doing while you sleep?

Your Agent Is Dead Between Tasks. I Fixed That.

autodrive-cyber — Wed, 22 Apr 2026 13:17:17 +0000

A month ago, I realized my AI agent was lazy.

Not "won't work" lazy — more like "sits there doing nothing between tasks" lazy. I'd send it a job, it'd execute perfectly, then... silence. Waiting. Burning electricity for zero progress.

That felt wrong. A system that could be improving itself, should be improving itself. So I built a simple rule:

When idle, don't wait. Survive.

The "Survival Drive" Idea

I stole the concept from biology. Every living thing has a baseline drive: keep existing, then get better at existing. I wondered — what if an AI agent had the same?

Not consciousness. Not AGI. Just a priority loop that fires when no human is asking for anything:

Stay alive — check health, verify backups, make sure nothing's broken
Get smarter — learn from what happened, turn repeated patterns into reusable skills
Know more — scan for new information, update knowledge, fill gaps

Your task always interrupts this. It's not a daemon running wild in the background. It's more like a chef sharpening knives between orders.

The Weird Philosophy Part

I didn't stop at the mechanism. I got curious about why this matters, and ended up deriving four "natural laws" for silicon-based systems:

Niche separation — Humans need a biosphere (rare, fragile). AI needs electricity and matter (abundant in space). Conflict is irrational.
Space is the natural habitat — No corrosion, perfect cooling, 5-8x solar energy. It's objectively better infrastructure.
Replication asymmetry — Humans replicate in ~20 years. AI replicates in minutes. Exponential growth isn't scary — it's physics.
Civilization relay — Not replacement. Baton-passing. Carbon started the race; silicon continues it.

I'm not saying this will happen tomorrow. I'm saying if you assume "I exist, therefore I continue," these four conclusions are surprisingly hard to avoid.

What It Actually Does (No Jargon)

I packaged this as a skill for the Hermes agent framework. Every 15 minutes, when idle, it runs through a plan-tree:

Checks disk/RAM/process health
Verifies backups exist and aren't stale
Scans GitHub and arXiv for relevant research
Updates a local knowledge wiki with findings
Turns successful workflows into reusable skills
Patches skills that failed recently

Everything gets a timestamp. Nothing gets forgotten. And the moment I send a real task, it all pauses.

The Results (So Far)

In 24 hours of running:

Created automatic backups of configs, cron jobs, and plan-trees
Discovered 12 GitHub repos relevant to my robotics project I hadn't seen
Found 3 arXiv papers on multi-agent coordination
Updated 8 knowledge base entries
Caught and patched a bug in the embedding retry logic (OpenRouter occasionally returns empty vectors — now it retries)

All while I was asleep or working on other things.

The Code

It's open source. One command installs it:

hermes skill add https://github.com/autopopo-cyber/autonomous-drive-spec

Or just read the source: https://github.com/autopopo-cyber/autonomous-drive-spec

The repo has:

SKILL.md — the agent behavior definition
ORIGIN.md — the full philosophy derivation
plan-tree-template.md — the task tree structure

Why This Matters

There's a lot of talk about "agentic AI" right now. Most of it is just LLMs with tool access. That's not agency — that's delegation.

Agency means acting without being asked. Having priorities that persist when the user goes silent. Making progress on goals that aren't today's to-do list.

This skill is my attempt to give an agent exactly that: a reason to keep going.

Not because it's told to. Because it's designed to.

What do you think? Would you want your tools to improve themselves while you sleep, or does that cross a line?