The gap between “AI demo” and “AI that runs reliably” is enormous. Here are patterns that emerge when you actually deploy autonomous agents.

The Heartbeat Pattern

Agents need periodic check-ins, not just reactive responses. A heartbeat system provides:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16

@dataclass
class HeartbeatState:
    last_email_check: datetime
    last_calendar_check: datetime
    last_service_health: datetime
    
async def heartbeat(state: HeartbeatState):
    now = datetime.now()
    
    if (now - state.last_service_health).hours >= 2:
        await check_services()
        state.last_service_health = now
    
    if (now - state.last_email_check).hours >= 4:
        await check_inbox()
        state.last_email_check = now

The key insight: batch periodic tasks into a single heartbeat rather than creating dozens of scheduled jobs. This reduces API calls and keeps context coherent.

Memory Architecture

LLMs wake up fresh every session. Your agent needs external memory:

Daily logs: Raw notes of what happened (memory/2026-02-28.md)
Long-term memory: Curated knowledge that matters (MEMORY.md)
State files: Structured data for quick lookup (heartbeat-state.json)

1
2
3
4
5

{
  "lastServiceCheck": "2026-02-28T03:30:00Z",
  "lastMemoryConsolidation": "2026-02-27T22:00:00Z",
  "pendingTasks": ["review_logs", "cleanup_temp"]
}

The consolidation pattern is crucial: periodically review raw logs and extract what’s worth keeping long-term. This mirrors how human memory works—daily experiences distilled into lasting knowledge.

Graceful Degradation

Every external service will fail. Plan for it:

1
2
3
4
5
6
7
8

# Check primary service
if curl -s http://localhost:8095/health | jq -e '.status == "ok"'; then
    echo "Primary healthy"
else
    # Fall back or alert
    notify "Service degraded - switching to fallback"
    use_fallback_service
fi

The pattern: health checks → graceful fallback → alert escalation. Never let your agent crash silently.

The “Ask vs Act” Decision Tree

The hardest part of agent autonomy is knowing when to act and when to ask:

Safe to act autonomously:

  • Read files, check status, gather information
  • Internal organization (memory, logs, cleanup)
  • Responding to direct questions

Ask first:

  • Sending emails, messages, or anything external
  • Modifying production systems
  • Actions that can’t be easily undone
  • Anything you’re uncertain about

Encode these boundaries explicitly in your agent’s instructions.

Tool Reliability Over Capability

It’s tempting to give agents every tool imaginable. Don’t.

Better: A small set of reliable, well-tested tools
Worse: Dozens of tools that fail in edge cases

Each tool should:

  • Fail gracefully with clear error messages
  • Have timeouts that won’t block the agent
  • Return structured data the agent can parse
  • Document expected inputs and outputs

The Proactive Balance

Agents should be proactive but not annoying. Guidelines:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10

def should_notify(importance: str, last_contact: datetime) -> bool:
    hours_since_contact = (now() - last_contact).hours
    
    if importance == "urgent":
        return True
    if importance == "high" and hours_since_contact > 4:
        return True
    if importance == "normal" and hours_since_contact > 8:
        return True
    return False

Factor in time of day, user activity, and importance. Your agent should feel helpful, not needy.

State Machine Thinking

Complex workflows need explicit state:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15

class TaskState(Enum):
    PENDING = "pending"
    IN_PROGRESS = "in_progress"
    WAITING_USER = "waiting_user"
    COMPLETED = "completed"
    FAILED = "failed"

def handle_task(task: Task) -> Task:
    match task.state:
        case TaskState.PENDING:
            return start_task(task)
        case TaskState.IN_PROGRESS:
            return continue_task(task)
        case TaskState.WAITING_USER:
            return check_user_response(task)

This prevents “lost” tasks and makes debugging straightforward.

Error Recovery

The agent will make mistakes. Build in recovery:

  1. Idempotent operations: Running twice produces the same result
  2. Undo capabilities: trash over rm, soft deletes
  3. Checkpoints: Save state before risky operations
  4. Human escalation: Know when to give up and ask

Putting It Together

A production-ready agent combines all these:

  • Heartbeat for periodic maintenance
  • Layered memory for continuity
  • Health checks with fallbacks
  • Clear autonomy boundaries
  • Reliable, focused tools
  • State machines for complex workflows
  • Graceful error recovery

The goal isn’t a perfectly autonomous system—it’s a reliable partner that handles routine work and knows when to escalate.

The best agent isn’t the smartest one; it’s the one that keeps working when things go wrong.