Awesome Agentic Loops — Agentic Loop Atlas

AI agents do not need more prompt dumps. They need operating loops that know when to act, prove, remember, and stop.

Awesome Agentic Loops — the Agentic Loop Atlas — is a proof-oriented library of reusable AI-agent operating patterns for Claude Code, Codex, Cursor, Hermes, OpenCode, and durable agent runtimes.

Motion is not progress; proof is.

Use this when your agents, cron jobs, or coding copilots need to move from “interesting automation” to repeatable operational discipline:

• research should become a public-ready artifact, not a notes graveyard
• PRs and CI need bounded babysitting without endless context drift
• cost, quota, and provider failures need decision-ready evidence
• agent meshes need health checks, role boundaries, and receipts
• launch workflows need approval gates instead of accidental posting

A loop only belongs here when it has:

• a clear trigger
• a bounded action
• concrete proof
• durable memory/state guidance
• a falsifiable stopping condition
• explicit risk and approval gates
• at least one runnable example or receipt shape

Tagline: Not prompts. Operating loops — with receipts.

• GitHub repository

Start with these loops

What makes a loop proof-grade?

A proof-grade loop is not a vibe, a prompt, or a one-off script. It is an operating contract:

trigger → bounded action → verification → memory/state update → stop condition → receipt

Why this exists

Agentic loops are moving from hype to operating discipline. The useful question is no longer “what prompt should I type?” but:

What system prompts the agent, checks the result, remembers the state, and knows when to stop?

Most awesome-agent lists collect tools. Agentic Loop Atlas collects operating patterns.

Quick start

1. Pick a loop from loops/.
2. Check its risk_level and approval_gate.
3. Adapt the commands to your agent/runtime.
4. Run one bounded iteration.
5. Keep the receipt; do not trust vibes.

For integration patterns, see docs/integration.md. For the portable registry direction, see docs/evolution-roadmap.md and registry/.

Runtime pattern

Use the loop card as the contract around your agent, not as a magic prompt:

Claude Code / Codex / Cursor / Hermes / OpenCode
        ↓
loop card: trigger + action + proof + stop condition
        ↓
receipt: what changed, what was verified, what still needs approval

For scheduled work, keep daily outputs compact and deterministic. Use stronger LLM review only for weekly quality checks, errors, or promotion decisions.

Loop card schema

Every loop follows schemas/loop-card.schema.json and this shape:

id: AAL-LOOP-001
name: Core Hygiene Sweep
category: operations
use_when: Source-of-truth docs may have drifted.
trigger: Manual request, milestone, or scheduled hygiene scan.
action: Inspect bounded files and detect contradictions.
proof: Diff, no-drift report, or issue list with owners.
memory: Source-of-truth docs only; no raw transcript hoarding.
stopping_condition: Stop after one bounded pass or when all contradictions have owners.
risk_level: docs
approval_gate: push
max_iterations: 1
cost_guard: one bounded run
works_with: [Hermes, Claude Code, Codex, Cursor]
failure_modes: [scope creep, stale context, accidental broad rewrite]
example_receipt: examples/aal-loop-001-core-hygiene-sweep-receipt.md
status: proof-grade

Initial loop set

Repository map

.github/                     Issue and PR templates
LICENSE                      MIT license
SECURITY.md                  Security and redaction policy
ROADMAP.md                   Project roadmap
catalog.json                 Machine-readable catalog
llms.txt                     Agent-readable guide
docs/announcement-draft.md   Public announcement draft, not posted
docs/positioning.md          Public positioning and contribution standard
schemas/loop-card.schema.json JSON Schema for loop cards
loops/                       Canonical loop cards
examples/                    Receipts and real-world proof examples
docs/                        Taxonomy, platform matrix, launch notes

Guardrails

• No loop is accepted without proof and stopping condition.
• Destructive, credential, deploy, billing, and external-message actions need explicit human approval.
• “Run while you sleep” is not a strategy. It is a liability unless proof, cost, and rollback exist.
• The agent that created the output should not be the only judge of the output.

Contributing

Start with CONTRIBUTING.md or the GitHub issue templates. The highest-value contributions are real receipts from agent runs.

• loop card metadata
• use case and trigger
• bounded action
• proof requirements
• memory/state guidance
• stopping condition
• approval gates
• failure modes
• example receipt or receipt template

If it lacks proof or a stop condition, it is not ready.

Status

Seeded from LOOP-MKT-20260622 research and Mustafa Saraç's Agentic Project Mesh proof pattern. The first eleven loop cards are proof-grade seed patterns with receipt examples.

Current posture:

• daily draft loop: bounded market scan → draft artifact package → receipt
• weekly quality review: promote only the loops that remain useful and non-repetitive
• public boundary: repo artifacts may be published; social posts, releases, deploys, credentials, and external messages remain explicit human decisions

The goal is not the largest list. The goal is the most reusable set of proven agent operating loops.