Loop engineering + graph engineering
are the stack. AGI CLI is both.

01The split — and why most stacks break it

02Loop engineering → what AGI CLI gives you

A production loop is not “chat with tools.” It is identity, skills, permissions, secrets, durable state, and recovery — around the model call.

# One well-engineered loop
agents run claude@2.1.207 "Land RUSH-1234" \
  --mode edit --secrets eng --model best
agents sessions --active
agents sessions <id> --markdown --last 5

03Graph engineering → what AGI CLI gives you

Topology is not a YAML research paper. It is named nodes, explicit edges, parallel ready sets, joins, and placement across machines.

# Graph: parallel implementors + join QA
agents teams create ship --enable-worktrees --devices yosemite-s0,yosemite-s1
agents teams add ship claude "API" --name backend  --worktree api --device yosemite-s0
agents teams add ship claude "UI"  --name frontend --worktree ui  --device yosemite-s1
agents teams add ship claude "E2E" --name qa --after backend,frontend --worktree qa
agents teams start ship --watch

04They compose — the factory shape

AGI CLI’s README already says it: a framework for running a distributed agent factory. That is loop × graph × fleet.

05Same ideas in popular frameworks

Loop and graph engineering are not proprietary to any one product. The same shapes show up in LangGraph, Conductor, Airflow agent tasks, and coding-AGI CLIs. Below: illustrative snippets of the shared vocabulary — not a ranking.

A · Agent loop (Loop 1)

Model + tools + repeat until done. LangChain’s simplest loop; every coding agent does this under the hood.

# create_agent: model calls tools until done
from langchain.agents import create_agent

agent = create_agent(
    model="…",
    tools=[search, write_file, open_pr],
)
agent.invoke({"messages": [user_request]})
# Verification loop (Loop 2): wrap with a grader
# that retries when rubric fails

# One coding-agent loop on a real harness
agents run claude "Draft the pricing API" \
  --mode edit --model best

# Durable transcript of the loop
agents sessions --active
agents sessions <id> --markdown --last 5

LangChain “Art of Loop Engineering”: agent loop → verification → event-driven → hill-climbing. Coding CLIs embody Loop 1 + partial 2/3 via second agents, CI, and schedules.

B · Graph of steps (fixed structure)

Nodes do work; edges decide what runs next. LangGraph’s classic “encode structure the model shouldn’t invent every time.”

# Nodes + edges (Python sketch)
graph.add_node("classify", classify)
graph.add_node("github", github_agent)   # full agent
graph.add_node("docs", docs_agent)
graph.add_node("synth", synthesize)

graph.add_edge("classify", "github")
graph.add_edge("classify", "docs")     # parallel
graph.add_edge("github", "synth")
graph.add_edge("docs", "synth")         # join
# Conditional edges / Send API for
# runtime fan-out width when needed

# Named nodes; --after = inbound edges
agents teams add t claude "API" \
  --name api --worktree api
agents teams add t claude "UI" \
  --name ui --worktree ui
# join: waits for both
agents teams add t claude "E2E" \
  --name qa --after api,ui --worktree qa
agents teams start t --watch
# wave 1: api ∥ ui · wave 2: qa

C · Loops vs DAGs (important nuance)

LangChain’s three-year graph note: production agent systems usually need cycles (retry, revise, human pause). A pure DAG is often the outer schedule; each agentic node still runs an inner cyclic loop. “Loops are simple graphs.”

D · Event-driven loop (Loop 3)

Something fires; the agent runs without you typing. Same pattern, different products.

E · Durable multi-step workflows

When the graph must survive restarts and long waits, the same topology shows up in workflow engines.

# Temporal-style idea (conceptual): activities = agent steps, workflow = topology
# Airflow AI SDK: @task.agent nodes in a DAG — parallel after upstream succeeds
# Conductor: YAML multi-agent graph, deterministic routing

# Coding-factory expression of durable team state:
# team meta.json on disk · start --watch rescans · supervisor restarts mid-flight
agents teams status ship
agents teams start ship --watch   # pick up pending --after when ready

06Why this is popular now — and why AGI CLI fits

• Models got good enough that multi-step work fails on coordination, not IQ.
• Linear chains broke under parallel surfaces (DAG-first articles, Apr 2026+).
• LangGraph / Conductor / crews made topology visible — users now ask for the same in the coding CLI they live in.
• Fleet reality: subscriptions and GPUs sit on many machines; placement is part of the graph.

AGI CLI’s advantage is not another framework in Python — it is your existing AGI CLIs, orchestrated:

• Same Claude / Codex / Grok / Cursor you already run
• Same subscriptions and keychain secrets
• SSH fleet you already own
• Disk-backed state (sessions DB, team meta) so supervisors restart

07One recipe that uses both

# LOOP: skill + secrets + mode on every node
# GRAPH: DAG + worktrees + devices

agents teams create landing --enable-worktrees \
  --devices yosemite-s0,yosemite-s1 -d "Ship pricing page"

agents teams add landing claude "Implement pricing API" \
  --name api --worktree api --mode edit --model best

agents teams add landing claude "Build pricing UI" \
  --name ui --worktree ui --mode edit

agents teams add landing claude "Playwright + ship checklist" \
  --name qa --after api,ui --worktree qa --mode edit

agents teams start landing --watch

# Observe loops inside the graph
agents sessions --teams
agents teams status landing
agents teams message landing qa "Skip flaky snapshot; land the rest"

Deeper dives (siblings):

• Sessions · index + cross-device query (loop memory / recall)
• Teams · DAG orchestration (graph runtime)