name: longgraph description: Author and optionally direct-launch one durable loop-graph run for long-horizon agent work. Use when the user invokes /longgraph (or legacy /octopus), asks to design or start a multi-round run, needs durable state, gated milestones, owner decision boundaries, cross-host continuity, or independent audit. Detect Codex or Claude Code from context instead of asking. For unused/duplicate/slim loops, use /loop-converge. For a self-contained task, recommend the host's ordinary task or goal directly. Do not execute or resume existing runtime node files from this authoring skill.

longgraph — author a loop-graph run

Formerly published as octopus / /octopus / octopus-skill. Same method; new brand. Slash /octopus remains a supported alias where the host still resolves that skill name (see install legacy symlink).

longgraph authors through loop-graph. Specialized entries such as loop-converge bind a preset pack and then follow that skill. Do not execute the generated runtime nodes from this authoring skill.

Fit check

• Use loop-graph when the work needs durable state, many rounds, milestone gates, owner boundaries, host switching, or independent verification.
• If the request is specifically multi-round unused / duplicate / reuse / slim work, read and follow loop-converge instead of designing the North Star from scratch.
• If the request is one self-contained task that fits a normal host goal/task, explain that longgraph adds no value and recommend sending the task directly. Do not wrap it in another objective or invent a lighter longgraph mode.

Shared reference: lib/methodology.md explains why the graph's discipline exists. The loop-graph author loads one small per-host reference only after the host is selected.

longgraph

Long-horizon agent skill for Claude Code, Cursor, Codex & Grok Build.

Stop agent drift with a durable ledger, a clean-context supervisor, and verified gates. Queue many long tasks in one loop — even unrelated ones — and keep going after a host switch by re-sending the same prompt against the files.

Design once → compile a durable loop-graph → verify all the way to done.

English · 简体中文

longgraph (longgraph-skill) is a curated agent skill and cross-host prompt library for long-running / long-horizon agent work — multi-hour coding, multi-milestone migrations, a queue of long tasks in one loop (they need not be related), and anything that outlives one context window. It is graph engineering for agents: specialized roles (executor · supervisor · scout) connected through durable, inspectable files — not another orchestration runtime. Because the scoreboard lives on disk, you can change hosts mid-run: open the same workspace, re-send the frozen node prompt, and continue.

One durable graph, portable across hosts. For a simple self-contained goal, use the host's normal task or goal directly; longgraph starts where durable graph structure adds value.

Renamed from octopus. Same library; primary brand is now longgraph / longgraph-skill / /longgraph / .longgraph/. Older posts that say octopus-skill, /octopus, or .octopus/ still work via GitHub repo redirect, install legacy symlinks, and in-flight run-dir alias (see Install and Migration).

Evidence

These are not one-shot demos. longgraph is a Markdown skill / prompt library (not an orchestration runtime). The table mixes checkable public Git, a function-only redacted multi-day pattern, and synthetic pedagogy.

How to read the clock. The self-iteration window’s ~14 days / ~340 hours is project wall-clock (first public commit → frozen anchor), not continuous model execution and not a claim of unattended production autonomy. Re-check Git with the commands in the self-iteration case. The redacted multi-day card uses coarse buckets only and is not private-Git re-checkable — see its evidence boundary.

Publication rules for future cases: public / private boundary.

When to use this

Reach for longgraph when you need any of:

• A long-horizon agent that keeps working after context compaction / session resets
• A durable task ledger (single scoreboard) instead of chat-memory progress
• Several long tasks in one loop — a continuous queue, even when items are unrelated
• Host-portable continuity — switch Claude Code ↔ Cursor ↔ Codex ↔ Grok Build mid-run by re-sending the prompt against the same files
• An independent clean-context supervisor — not the same agent grading itself
• Verified done: acceptance gates re-run against real output, not self-reported “done”
• Multi-milestone work with non-skippable gates and explicit owner red lines
• A Markdown skill / prompt library that works across Claude Code · Cursor · Codex · Grok Build

When not to use this

• One-shot edits, small PR-sized tasks, or anything that fits a single clean session
• You want a runtime framework (LangGraph, CrewAI, AutoGen, custom agent server)
• You only need a single short prompt with no ledger, gates, or independent review

How it compares

Also called / related searches: longgraph skill, long-horizon agent skill, long-running agent skill, prevent agent drift, multi-task agent loop, switch AI coding host mid-task, Claude Code multi-agent supervisor, Grok Build agent loop, agent ledger, loop-graph, graph engineering for agents, clean-context review.

Why longgraph

Long-running agents tend to drift in predictable ways: scope expands, “done” becomes self-reported, tests stop proving the real path, and early decisions disappear from context. longgraph moves the safeguards outside the model’s memory:

• Verified, not merely written — acceptance gates are rerun against real output.
• Durable state — the ledger survives context loss and remains the single scoreboard.
• Many long tasks, one loop — the ledger is a continuous queue; items can be independent (migrations, test debt, docs, gates) without forcing one mega-goal.
• Host-portable — progress is files under .longgraph/<date-slug>/, not chat history. Point another host at the same workspace, re-send the compiled node prompt, and pick up the next open ledger item.
• Clean-context review — an independent supervisor can catch drift the executor cannot see.
• Forced convergence — growth is periodically stopped, measured, and simplified.
• Low-friction owner decisions — genuine owner-only calls arrive as a short recommended A/B/C choice, not a technical homework assignment.

It is Markdown, not an orchestration framework: no application runtime, server, or vendor lock-in. Install as a Claude Code plugin, symlink into Codex / Cursor (see install script), or run prompts-only on Grok Build (and other hosts) via the per-host references.

Multi-task loops & switching hosts

One loop is a queue, not a single story. Each round still does one ledger item end-to-end (implement → verify → record), but the ledger can hold many long items at once — related milestones or unrelated backlog (the gate-wait backlog pattern is the extreme case: useful work with no dependency on the item under audit). You do not need a new graph every time the next long task is about something else.

The host is swappable; the files are not. A compiled loop-graph run freezes prompts and state under .longgraph/<date-slug>/. To continue elsewhere:

1. Use a workspace that can see those files (and the project).
2. Re-send the same frozen executor (and, if used, supervisor) prompt on the new host.
3. The node reads ledger.md / directives.md and continues from the next open item.

You are not exporting chat transcripts. Invocation syntax still follows each host’s dialect (per-host references) — only the progress is portable.

Is longgraph the right tool?

Rule of thumb: if you do not need the graph, do not use longgraph.

Quick start

Claude Code

Install the plugin from the marketplace:

/plugin marketplace add levi-qiao/longgraph-skill
/plugin install longgraph@longgraph-skill

Codex or Cursor

Install the library and symlink /longgraph and `/loop-co