---

Temporal is great if you have a DevOps team to manage a cluster. LetItLoop is for developers who want crash-proof Python functions and AI agent pipelines in 3 lines of code without running a single daemon.

---

⚡ Quickstart

from letitloop import durable, step, atomic_marker


@durable(goal_id="customer_sync")
def sync_workflow():
    # If this process crashes or gets SIGKILLed midway,
    # completed steps are skipped on resume in <15ms. Zero duplicate tokens wasted.
    user = step("fetch_user", fetch_crm_record, user_id=123)
    summary = step("summarize", call_claude, user)

    # Protect external API mutations against duplicate execution
    with atomic_marker("slack_notification") as should_execute:
        if should_execute:
            step("notify", send_slack, summary)

    return summary


if __name__ == "__main__":
    sync_workflow()

pip install letitloop

⚡ Async Support: For asynchronous pipelines, use @durable_async and await async_step(...) with full asyncio.gather() isolation.

---

🔄 Process Liveness: Auto-Supervision & CLI Watcher

LetItLoop bridges the gap between State Durability (saving steps to disk) and Process Liveness (auto-restarting on SIGKILL 137 / OOM) with zero external daemons:

1. Terminal Watcher (lil watch)

Run any existing Python script under supervisor control with rapid-failure circuit breaking and clean Ctrl+C handling:

# Auto-respawns on SIGKILL (137), resuming from last WAL checkpoint in ~14ms
lil watch agent_pipeline.py --max-restarts 10 --backoff 1.0

2. In-Code Programmatic Supervisor (@supervise)

from letitloop import durable, step, supervise


@supervise(max_restarts=5, backoff=1.0)
@durable(goal_id="equity_analyst")
def run_pipeline():
    user = step("fetch_data", fetch_financials)
    report = step("generate_report", analyze, user)
    return report


if __name__ == "__main__":
    run_pipeline()

---

💎 The 3 Architectural Moats

1. Zero-Daemon Local Durability (Zero Infrastructure)

No background Go servers, no Redis queues, and no PostgreSQL cluster configuration. LetItLoop embeds a single-file Write-Ahead Log (LILWAL02) that logs step outputs atomically. If your script dies from SIGKILL (137), OOM, or spot eviction, running the script again instantly fast-forwards to the exact interrupted step in ~14ms.

2. Source-Span AST Node Splicer (0% Comment Loss)

Temporal and existing orchestrators only manage task state. LetItLoop includes a surgical Python concrete syntax tree (CST) engine built specifically for self-coding AI agents:

• Replaces targeted functions and classes with surgical precision.
• 0% Comment Loss: Guarantees module docstrings, inline comments, licensing headers, and class indentation are never stripped or hallucinated away by LLM whole-file rewrites.

3. Proof-Carrying CI Gate (letitloop-action)

LetItLoop generates signed HMAC-SHA256 receipts recording execution invariants and test outputs. Drop letitloop-action@v2 into GitHub Actions to block AI pull requests from hallucinating passing test outputs or altering protected function signatures.

---

📊 DCP-2.0 Agent Durability Conformance Benchmark

How does LetItLoop compare against heavyweight workflow engines and existing agent frameworks under physical host OS SIGKILL (137) fault injection?

Empirical results from the open DCP-2.0 Durability Benchmark:

[!NOTE] Methodological Disclosure & Architectural Trade-offs:

1. Why 100% durability is physically impossible: If a non-maskable SIGKILL strikes while an uncommitted external network request is actively in flight, that single step must be re-executed upon resume, producing an empirical ~1.4%–2.8% token re-execution overhead.
2. The I/O Overhead Trade-off: LetItLoop trades ~3.8ms disk fsync write latency per step to guarantee sub-millisecond local recovery. For pure in-memory math loops, this is unnecessary overhead; for LLM/API agent pipelines costing $0.10–$2.00 per step, paying 3.8ms disk I/O to guarantee zero lost progress is an overwhelming net win.

---

🔄 Durability vs. Liveness (Auto-Supervision)

• Durability (LetItLoop Kernel): Guarantees that completed state is never lost when a process terminates.
• Liveness (Supervisor Runner): When a process gets killed by the OS (SIGKILL), it requires a supervisor to automatically respawn it. LetItLoop provides built-in supervision:

# Supervise execution and auto-respawn process on unhandled SIGKILL/crash until completion
lil run --task auth-refactor --supervise --strict

---

🍳 Framework Recipes & Community Cookbooks

Explore runnable self-contained examples in examples/:

---

🛡️ GitHub Action CI Gate (v2)

Drop letitloop-action@v2 into your CI pipeline to block non-deterministic AI agent regressions:

name: LetItLoop Proof-Carrying CI Gate
on: [pull_request]

jobs:
  verify:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4
      - uses: sdageltc/letitloop-action@v2
        with:
          github-token: ${{ secrets.GITHUB_TOKEN }}
          strict-ast: 'true'

---

📜 Architecture Decision Records (ADRs)

Core design invariants are documented under docs/adr/:

• ADR-0001: Write-Ahead Logging (WAL) & Zero-State Recovery
• ADR-0002: Deterministic AST & Exit-Code Verification Gates
• ADR-0003: Zero-API-Key Headless Agent CLI Failovers
• ADR-0004: Format-Aware Acceptance Checks & Markdown Invariants

---

License

Distributed under the MIT License. Copyright (c) 2026 sdageltc. See LICENSE for details.