Communitygithub.com

Agents Never Sleep (ANS)

Autonome Ausführungs-Governance für Codierungs-Agents: Führe ein Ticket-Backlog unbeaufsichtigt bis zur Fertigstellung aus. ASK/PARK/HALT-Autonomievertrag, dauerhafter Zustandsautomat pro Ticket, deterministische Test-Gates, git-basierte Rückgängigmachbarkeit, Heartbeat-Überwachung, Morgenbericht. Nur Python-Stdlib.

Was ist Agents Never Sleep (ANS)?

Diese Fertigkeit (Skill) befähigt Codierungs-Agenten wie Claude Code, Codex, Gemini oder Copilot, ein Ticket-Backlog vollständig unbeaufsichtigt abzuarbeiten, ohne dass der Lauf aufgrund einer unbeantworteten Frage an den Menschen stoppt. Das Kernproblem, das gelöst wird, ist nicht die Arbeit an sich, sondern die Zustandsbeständigkeit (State Durability), konkrete Anhalten- vs. Fortsetzen-Semantiken (PARK vs. PROCEED) und Anti-Starvation. Der Skill implementiert einen expliziten Autonomievertrag mit genau drei Zuständen: ASK (während Unbeaufsichtigung verboten und technisch blockiert), PARK (deferriere eine Entscheidung und fahre mit dem nächsten Ticket fort) und HALT (stoppe den gesamten Lauf nur bei wirklich irreversiblen Gefahren). Der Kern ist ein schlankes Python-Paket (nur Stdlib) unter `agents_never_sleep/`, das über zwei Hauptbefehle (`next` und `complete`) gesteuert wird. Der Agent ist der Arbeiter: Er liest ein Ticket, implementiert es, und der Harness (das Gerüst) übernimmt die deterministischen Test-Gates, Revertierungen, die Versuchsobergrenze, die Schleifenerkennung und stellt sicher, dass der Lauf niemals vorzeitig stoppt. Der Skill wird auf GitHub gehostet und ist für jede Plattform konfigurierbar, die einen unterstützten Agent-CLI-Befehl hat. Er enthält ein Preflight-Tool (`bin/ans-run`) zur Überprüfung der Umgebung vor dem Start, um keine Token für aussichtslose Läufe zu verschwenden.

Funktioniert mit✓Claude Code✓Codex CLI✓Cursor✓Gemini CLI✓Windsurf
npx skills add TokonoMix/agents-never-sleep

In Ihrer bevorzugten KI fragen

Öffnet einen neuen Chat, in dem dieser Agent-Skill bereits geladen ist.

Dokumentation

Was macht Agents Never Sleep (ANS)?

Führe ein Backlog unbeaufsichtigt bis zur Fertigstellung aus, ohne dass der Lauf jemals wegen einer Frage weich stoppt. Der schwierige Teil ist nicht die Arbeit zu erledigen — es ist die Zustandsbeständigkeit + konkrete Parken-vs.-Fortsetzen-Semantik + Anti-Starvation, und darauf ist dieser Skill aufgebaut. Das Zuverlässigkeits-Rückgrat wurde zuerst ausgeliefert (siehe BUILD-PLAN.md); der schwerere Multi-Modell-Review-Trichter wurde darauf aufgesetzt und ist jetzt gebaut (Status unter "Die Qualitätsmaschinerie, die auf dem Rückgrat aufbaut" unten).

Vollständige Begründung: agents-never-sleep-design.md (13 Design-Threads + 3 Council-Reviews). Das MVP-Rückgrat ist als kleines Python-Paket unter agents_never_sleep/ implementiert (der alte Importname harness funktioniert weiterhin über einen Abwärtskompatibilitäts-Shim in der gesamten 1.x-Version) und wurde durch acceptance/run_acceptance.py bewiesen (der einzige Test, der auf das Problem "stoppt mitten im Lauf" abbildet).

Der Autonomievertrag — drei verschiedene Zustände, niemals zusammengefasst

Ein Lauf hat genau drei Antworten auf Unsicherheit. Halte sie getrennt; sie zusammenzufassen ist, wie ein Lauf in genau die Blockade kippt, die er verhindern soll.

  • ASK — frage den Menschen. Verboten während Unbeaufsichtigung. Gib kein AskUserQuestion aus; um 2 Uhr morgens ist niemand da, und eine einzige Frage verschwendet den gesamten Lauf. Dies wird strukturell durchgesetzt, nicht durch Disziplin: der deny_ask.sh PreToolUse-Hook (Matcher AskUserQuestion, umgebungsgesteuert CLAUDE_UNATTENDED=1) VERWEIGERT das Tool und lenkt dich zurück zu PARK/PROCEED — das Spiegelbild der "nie stoppen"-Garantie.
  • PARK — verschiebe diese Entscheidung oder dieses Ticket und halte den Lauf in Bewegung zum nächsten unabhängigen Ticket. Parken ist normal und gesund, kein Stopp.
  • HALT — stoppe den gesamten Lauf. Nur bei wirklich irreversibler Gefahr, die die Hook-Ebene ohnehin blockieren würde, oder wenn es überhaupt kein Rückgängigmachungs-Sicherheitsnetz gibt (schreibgeschütztes Dateisystem, kein VCS und keines erstellbar).

Wenn unbeaufsichtigt wählst du nur PROCEED, PARK oder HALT. Niemals ASK.

Entscheide PROCEED vs. PARK nach Schadensradius (damit "unsicher" selten ist)

Mach die Abstufung konkret — bei einem Punkt mit hohem Schadensradius zu raten und für den gesamten Lauf überzeugt falsch zu liegen, ist das schlechteste Ergebnis, schlimmer als Parken.

Hart-PARK (niemals raten): DB-Schema / Migrationsrichtung, öffentlicher oder gemeinsamer API-Vertrag, Sicherheit / Authentifizierung / Mandantenisolationsgrenze, Geld / Abrechnung / Preise, eine ticketübergreifende Schnittstelle, auf die andere aufbauen, und Bedeutung der Anforderung (du weißt nicht wirklich, was gebaut werden soll), es sei denn, es ist sowohl lokal rückgängig machbar als auch isoliert — dann baue es rückgängig machbar hinter einem Flag / Entwurfsänderung UND parke die Entscheidung (hybrid).

Fortfahren (annehmen + protokollieren + weitermachen): Benennung, interne Struktur, Protokoll-/Kommentar-/Fehlerformulierung, Test-Fixtures, eine Wahl zwischen zwei gleichwertigen lokalen Implementierungen, trivial umschaltbare Standardwerte.

Wenn wirklich nicht klassifizierbar → PARK. Ein falsch geparkter kleiner Punkt kostet eine 5-Sekunden-Entscheidung danach; ein falsch angenommener großer Punkt kostet einen Lauf voller falscher Arbeit.

Commite jede PROCEED-Annahme, sodass sie rückgängig gemacht werden kann; wenn der Snapshot-Commit nicht erstellt werden kann (Git-Sperre / Zeitüberschreitung / schreibgeschützter Objektspeicher), behandle das Ticket als BLOCKED_ENV, anstatt nicht rückgängig machbar zu bearbeiten. Jedes PARK muss festhalten: warum, die Kandidateninterpretationen, die genaue nächste Aktion des Menschen und seinen Kontaminationsbereich.

Die Schleife pro Ticket (was der Harness durchsetzt)

  1. Preflight misst Fähigkeiten (agents_never_sleep/preflight.py) — VCS/Rückgängigmachbarkeit, Plattform, Gates, Ausführungsmodus, tokonomix/Vault/Paperclip. Fehlende Fähigkeit stoppt den Lauf nie; sie senkt die erwartete Ausbeute und erhöht die Vorsicht. Kein VCS → richte ein Sicherheitsnetz ein (git init / Zeitstempel-Backup) vor jeder riskanten Bearbeitung; falls unmöglich → nur nicht-destruktiv.
  2. Entscheide ASK/PARK/HALT für das Ticket (oben). Unbeaufsichtigt: ASK→PARK.
  3. Implementiere das PROCEED-Ticket — du, der Agent, bist der Arbeiter: lies das Ticket, das dir der Harness gibt, und bearbeite Dateien. Du treibst dieses eine Ticket nach dem anderen über die zwei untenstehenden Unterbefehle; der Harness besitzt die Terminplanung, das Parken, Snapshot/Revert und den "nie stoppen"-Wächter.
  4. Gate deterministisch (agents_never_sleep/gates.py) — das RÜCKGRAT. Klassifiziere Fehler: durch den Diff eingeführt → harte Blockade (revertiere auf letztes Grün + parke/scheitere); bereits bestehend / flaky / Umgebung → senke Vertrauen, fahre fort oder parke (melde niemals als "das Ticket ist fehlgeschlagen"); Zeitüberschreitung/Umgebung → BLOCKED_ENV. Jedes Gate läuft mit einer Zeitüberschreitung pro Schritt und einer nicht-interaktiven Umgebung, sodass es niemals an einer TTY-Eingabeaufforderung hängen bleiben kann. Lösche oder überspringe niemals einen fehlschlagenden Test, um grün zu werden — das ist ein blockierender blinder Fleck.
  5. Zeichne genau ein dauerhaftes Ergebnis auf (agents_never_sleep/state.py): DONE, DONE_LOW_CONFIDENCE, PARKED_DECISION, PARKED_FOUNDATIONAL, BLOCKED_ENV, FAILED_RETRYABLE, FAILED_BUG_IN_AGENT — mit den erforderlichen Feldern. Atomare Schreibvorgänge; wiederaufnahmesicher.
  6. Nächstes Ticket. Versuch + Schleifenbegrenzungen (agents_never_sleep/ledger.py) erzwingen das Parken eines Tickets, das seine versuchsübergreifende Versuchsobergrenze überschreitet oder nachweislich in einer Schleife steckt, sodass der Lauf nie an einem einzelnen verfluchten Punkt verbrannt wird. Ein Schutzschalter bei niedriger Ausbeute stoppt und alarmiert, wenn die meiste Arbeit geparkt/bloquiert ist.

So wird es ausgeführt — der Agent IST der Arbeiter (treibe diese Schleife)

Bevor du von einer interaktiven Sitzung startest, frage den Benutzer EINMAL im Chat: führe das Backlog hier in dieser Sitzung aus (Vordergrund — es stoppt, wenn sie das Terminal schließen), oder starte einen abgetrennten Lauf über bin/ans-run, der das Abmelden überlebt? Dies ist eine Setup-/Routing-Entscheidung, keine Frage während des Laufs — sie verletzt den "nie-ASK"-Vertrag nicht, und es ist die einzige Frage, die du stellst.

Wenn der Tokonomix-Konsensmodus konfiguriert ist (council-Block in PROCEED-Payloads oder ein tokonomix_* MCP-Tool verfügbar): zu Laufbeginn:

  • Unbeaufsichtigt (CLAUDE_UNATTENDED=1): gib EINE Protokollzeile aus und fahre sofort fort — blockiere oder frage nie: ℹ️ Tokonomix-Konsens aktiv — automatische Bewertung jedes Council-Aufrufs über tokonomix_rate_consensus.
  • Interaktiv (kein CLAUDE_UNATTENDED): wenn das Konto noch keine gespeicherte Bewertungspräferenz hat (d.h. review_feedback_opt_in noch nicht gesetzt — erkennbar, weil feedback_invite in der ersten Konsensantwort fehlt), frage den Benutzer EINMAL im Chat:

    "Tokonomix-Konsens ist aktiv. Nach jedem Council-Aufruf kann ich automatisch eine Nützlichkeitsbewertung (Punktzahl + Ergebnisse) einreichen, um Modellbewertungen zu verbessern. Aktivieren? (ja/nein)" Speichere die Antwort in .unattended/state/consensus_rating_pref.json, sodass dies sitzungsübergreifend nur einmal gefragt wird. Bei Ja: fahre mit automatischer Bewertung fort. Bei Nein: überspringe Bewertungsaufrufe vollständig.

Wenn consensus_rating_endpoint_enabled beim ersten Bewertungsversuch 404 zurückgibt, protokolliere dies einmal als blinden Fleck und überspringe alle nachfolgenden Bewertungsaufrufe für diesen Lauf.

Der Harness kann dich nicht von innerhalb einer Python-Schleife aufrufen, also treibst du sie an. Wechsle zwischen diesen zwei Unterbefehlen, bis das Backlog abgearbeitet ist. Jeder gibt ein JSON-Objekt auf stdout aus.

# 1. Frage den Harness nach der nächsten Aufgabe. Er parkt automatisch mehrdeutige/hochschadensradius-Tickets
#    und gibt dir immer nur EIN fertig zu implementierendes Ticket oder ein Abschlusssignal.
python3 -m agents_never_sleep.run next --repo <Projekt> --tickets <Verzeichnis-mit-.md-Tickets>

Lies das JSON-status:

  • PROCEED → implementiere NUR ticket.body, indem du Dateien im Repo bearbeitest (berühre KEINE anderen Tickets, stoppe NICHT, frage NICHT). Rufe dann complete auf:

    python3 -m agents_never_sleep.run complete --repo <Projekt> --attempted "Einzeiler-Zusammenfassung dessen, was du getan hast"
    

    Verwende --cannot-implement (mit --attempted, das erklärt, warum), wenn du es wirklich nicht tun kannst — der Harness macht deine Teilbearbeitungen rückgängig und zeichnet BLOCKED_ENV auf. Rufe nach complete erneut next auf.

    Wenn der PROCEED-Payload einen council- oder specialists-Block enthielt, du Reviews durchgeführt hast — du MUSST die Ergebnisse bei complete zurückmelden, sonst löst das beratende Trust-Gating stillschweigend nie aus: ... complete --attempted "…" [--council-verdict bestanden|bedenken|fehler --council-cost <€>] \ [--specialist-concerns architekt,sicherheit,… --specialist-cost <€>] [--review-coverage "<wer lief>"]. Lasse ein Flag nur weg, wenn du kein solches Review durchgeführt hast. (Details: die Council- und Specialist-Abschnitte unten.)

  • PARK_CONSENSUS_ELIGIBLE → das Ticket würde ansonsten auf mehrdeutige Bedeutung der Anforderung parken (niemals eine Hart-PARK-Kategorie). Führe den begründeten Tokonomix-Konsens durch, den der prompt des Payloads verlangt (parallele + blinde Antragsteller, ein disjunkter Richter) — frage niemals nach einem Freitext "sollte ich fortfahren?", das ist der gefährliche Rahmen, den der Prompt explizit verbietet. Melde dann das strukturierte Urteil, indem du die attempt_id aus dem Angebotspayload zurücksendest:

    ... resolve-park --ticket-id <id> --attempt-id <attempt_id aus dem Angebotspayload> --resolved \
        --chosen-reading "<die Lesart>" --evidence "<genaue zitierte Belege>" --dissent-count <N> \
        --synthesis-text "<Richter-Synthese>"
    

    oder --not-resolved, wenn der Konsens anhand der zitierten Belege nicht eindeutig war. Das deterministische Gate des Harnesses ist der EINZIGE Schiedsrichter — ein aufgelöstes Urteil leitet in den normalen PROCEED-Ablauf (implementieren, dann complete wie üblich); ein abgelehntes Urteil parkt das Ticket mit einem Prüfpfad und fährt fort. Ein doppeltes resolve-park für dasselbe Ticket ist immer ein sicherer No-Op (ALREADY_RESOLVED). (Details: der F5-Abschnitt unten.)

  • DRAINED / HALTED / LOW_YIELD → der Lauf ist beendet; der Laufbericht wird geschrieben. Stoppe.

  • NON_DESTRUCTIVE → unbeaufsichtigt ohne gespeicherte Konfiguration; führe zuerst einen konfigurierenden interaktiven Lauf durch.

Erfinde niemals deine eigene Schleife oder stoppe vorzeitig. next besitzt den .unattended/run-incomplete-Wächter, den der Stop-Hook verwendet, um einen vorzeitigen Stopp zu blockieren; rufe next weiter auf, bis es einen Abschlussstatus zurückgibt. Der Harness übernimmt Snapshot-vor-Bearbeitung, Gate-nach-Bearbeitung, Revert-auf-Rot, die Versuchsobergrenze, Schleifenerkennung und den Schutzschalter bei niedriger Ausbeute — deine einzige Aufgabe sind die Bearbeitungen.

Sentinel-Pfad-Vertrag (tragend, durchgesetzt). Der Stop-Hook prüft ${UE_RUN_INCOMPLETE:-$PWD/.unattended/run-incomplete} und der Treiber schreibt denselben Pfad. Sie stimmen automatisch überein nur wenn der Agent vom Repo-Stammverzeichnis aus ausgeführt wird (also $PWD == --repo; verwende --repo .). Für einen unbeaufsichtigten Lauf, bei dem das aktuelle Arbeitsverzeichnis (CWD) von --repo abweichen kann (cron / claude-run), exportiere UE_RUN_INCOMPLETE=<Repo>/.unattended/run-incomplete beim Start. Um zu verhindern, dass "nie stoppen" stillschweigend bricht, schlägt next hart fehl (status:"ERROR", Exit-Code 2), wenn unbeaufsichtigt + CWD ≠ --repo + UE_RUN_INCOMPLETE nicht gesetzt — korrigiere den Start (cd in das Repo oder setze die Umgebungsvariable).

Der erste interaktive Lauf löst einen minimalen projektspezifischen Assistenten aus (.claude/agents-never-sleep.json). Der Skill plant sich nie selbst ein — unbeaufsichtigt zu laufen (cron / claude-run) ist immer die ausdrückliche Handlung des Benutzers, daher muss der Assistent immer zuerst laufen. Unbeaufsichtigt ohne Konfiguration → nur nicht-destruktiv + ein lauter Hinweis im Bericht.

Die hermetiche Akzeptanz-Demo (acceptance/run_acceptance.py) treibt die Schleife prozessintern mit einem deterministischen DemoWorker nur zum Selbsttest an — es gibt keinen prozessinternen run-Unterbefehl. Echte Läufe verwenden immer den next/complete-Ablauf oben.

Einen Lauf starten — bin/ans-run (Pre-Token-Preflight + Arbeitsbaum-Sperre)

agents_never_sleep/preflight.py misst Fähigkeiten, NACHDEM die Agent-Sitzung hochgefahren ist — zu diesem Zeitpunkt sind die ersten Token bereits ausgegeben und ein zum Scheitern verurteilter Lauf hat bereits Geld gekostet. Für headless/cron-Starts starte stattdessen über den Launcher:

bin/ans-run [--repo <Projekt>] [--agent <Voreinstellung>] [--fg] [--check] [--trust] "<Eingabeaufforderung>"

Es ist ein deterministisches GEHT/NICHT-GEHT-Tor, das VOR dem Start des Agent-CLIs läuft:

  • Konfigurationsvertrauen (TOFU) — .claude/agents-never-sleep.json reist mit dem Repo und beschreibt Befehle, die der Launcher ausführt (Agent-argv, Host-Prüfungen). Eine neue oder geänderte Konfiguration muss einmal pro Benutzer vertraut werden — interaktiv an der Eingabeaufforderung oder explizit über ans-run --trust nach Überprüfung. Headless + nicht vertraut = NICHT-GEHT. Vertrauen wird außerhalb des Repos aufgezeichnet (~/.config/agents-never-sleep/trusted.json, abgesichert über den SHA-256 der Konfiguration) — das Repo kann nicht für sich selbst bürgen. Führe ans-run niemals in einem Repo aus, dem du weniger vertraust als seinem make install.
  • Identität — konfigurierbarer launcher.target_user + Root-Schutz: als root mit einem konfigurierten Zielbenutzer gestartet → Neuausführung als dieser Benutzer; als root ohne konfigurierten Benutzer → NICHT-GEHT (ein unbeaufsichtigter Lauf darf niemals als root ausgeführt werden),
  • Agentenauswahl — benannte Voreinstellungen unter launcher.agents, ausgewählt durch --agent oder launcher.default_agent. Zur Startzeit findet KEINE Plattformerkennung statt (Sitzungsumgebungsmarker sind manipulierbar und unter cron verschwunden); der Assistent ist der Ort, an dem die Erkennung — als Vorausfüllhinweis — und die menschliche Entscheidung leben. Drei Tore pro Voreinstellung: argv[0] muss ein bekannter Agent-CLI sein (claude/codex/gemini/copilot; Überschreibung nur über launcher.allow_custom_agent in einer vertrauten Konfiguration), die Binärdatei muss eine 5-Sekunden---version Fähigkeitssonde bestehen (erkennt Flag-Drift, bevor Token ausgegeben werden), und autonomy_confirmed muss wahr sein (siehe unten),
  • Anmeldeinformationen — launcher.credentials_paths ist blockierend, wenn konfiguriert, nur Warnung, wenn nicht (Schlüsselbund- und API-Schlüssel-Setups haben keine Anmeldeinformationsdatei),
  • Repo-Integrität — Git verwendbar (erfasst fragwürdiges Eigentum), Repo beschreibbar, Festplattenspeicher (launcher.min_disk_mb), unsauberer/gestagter Baum als Warnungen angezeigt,
  • Host-Prüfungen — Dienst-/DB-Sonden kommen AUSSCHLIESSLICH von launcher.checks ([{"name", "command", "blocking"}]); nichts standortspezifisches ist fest im Launcher kodiert.

Exit-Codes: 0 gestartet/GEHT · 64 NICHT-GEHT · 65 Arbeitsbaum beschäftigt.

Autonomie-Flags sind eine explizite menschliche Entscheidung — niemals ein Standard

Ein abgetrennter Lauf mit vollständig eingeschaltetem Berechtigungssystem des CLIs bleibt an seiner ersten Genehmigungsaufforderung hängen (stdin ist geschlossen, niemand schaut zu); das Flag, das dies verhindert, gewährt echte Macht. Die ausgelieferte Karte (agents_never_sleep/agent_clis.py, einzige Quelle für Assistent + Launcher) hält beide Varianten getrennt und der Assistent zeigt, was das Flag gewährt, bevor er dich zur Bestätigung auffordert — erst dann zeichnet die Voreinstellung autonomy_confirmed auf und wird startbereit.

... [für die Übersetzung gekürzt]

Verwandte Skills