explainx / blog
Andrew Ng's new knowledge-graph course and Linear's autonomous Loops feature reignited a familiar argument on X: structured graph orchestration versus simple imperative loops for AI agents. Here's what each side actually means.
Jul 18, 2026
Loops made individual agent behavior programmable. Graphs make the organization of agents programmable. On July 18, 2026, a single Peter Steinberger tweet — "Are we still talking loops or did we shift to graphs yet?" — triggered the next wave. explainx.ai maps what changed and what to build.
Jul 16, 2026
DoorDash opened a limited beta for dd-cli, a command-line interface that lets AI agents search restaurants, find deals, and complete real payments from the terminal. explainx.ai maps the apps-for-agents thesis, macOS-only waitlist constraints, Paul Graham memes vs skepticism, and checkout safety next to today's Codex $HOME news.
Jul 15, 2026
OpenAI's first branded hardware is a developer macro pad, not the rumored home companion. The Codex Micro pairs six frosted Agent Keys with Codex thread status, command shortcuts, and a reasoning dial — built on Work Louder's Creator Micro chassis. explainx.ai breaks down the $230 launch, RGB states, and the HTTP 410 stock joke.
Two unrelated product announcements collided on X in July 2026 and reopened one of agentic AI's oldest arguments under a new name: should agent orchestration look like a graph or a loop? The trigger was a new DeepLearning.AI course on knowledge graphs taught by Neo4j's Andreas Kollegger, posted alongside Linear's launch of Loops — a feature that lets Linear Agent run recurring, autonomous workflows without a human re-prompting it each time. The resulting thread pulled in developers, framework maintainers, and at least one "what the fuck is a graph" reply that collected 86 fire-emoji reactions.
The debate is worth untangling carefully, because "graphs" and "loops" in this conversation refer to at least three genuinely different things wearing the same two words — and confusing them is exactly how these arguments spin in circles every product cycle.
| Term | What it actually refers to | Example |
|---|---|---|
| Knowledge graph | A data structure of entities + relationships | Neo4j course content, Monarch Knowledge Graph |
| Graph-based agent orchestration | Control flow modeled as nodes/edges (state machine) | LangGraph, multi-agent DAGs |
| Loop (imperative agent loop) | Prompt → act → observe → repeat, minimal structure | Claude Code, Codex CLI, Linear Loops |
| Linear Loops (product feature) | Scheduled/triggered recurring agent workflows in Linear | Bug triage, doc updates, customer notifications |
The DeepLearning.AI course at the center of this — taught by Andreas Kollegger of Neo4j — is not about agent orchestration at all in the control-flow sense. It teaches how to turn raw, unstructured data into a structured knowledge graph using multi-agent systems built on Google's Agent Development Kit (ADK). That's a data-modeling problem: given messy source material (documents, transcripts, database exports), use a coordinated set of agents to extract entities and relationships and populate a graph database like Neo4j.
Knowledge graphs are the same underlying structure behind systems like the Monarch Knowledge Graph, which links genotype-phenotype data across species for rare disease research — a use case where relationships between entities (this gene, this variant, this phenotype, this disease) matter more than any single flat document. Building that structure automatically, at scale, from unstructured source material is genuinely hard, and it's a legitimate reason to reach for multiple coordinated agents: one to extract entities, one to resolve relationships, one to validate against an existing ontology.
Harrison Chase, creator of LangChain, captured the confusion directly on X: "So i didn't really know what graph engineering is, and i still don't really… but it's basically just langgraph?" — a reply that itself got 65 fire-emoji reactions, which tells you how many people in the replies were quietly nodding along rather than actually following the distinction. The honest answer is no: Ng's course is about the data structure a knowledge graph produces, not the orchestration framework LangGraph uses to control an agent's execution flow. They are unrelated systems that happen to share a noun.
Linear, the project management tool, shipped Loops as a new capability for Linear Agent: recurring workflows the agent runs on a schedule or in response to a trigger, without a human kicking off each run. Per Linear's announcement and CEO Karri Saarinen's post, example workflows include:
Linear co-founder Jori Lallo framed it plainly: "Linear is now one step closer to self-driving project management; automate anything from bug fixes to updating documentation." Chief business officer Cristina Cordova went further, tying it to a claim Linear made a year earlier: "Last year we said the future of software is self-driving. Loops are that future, live today."
Structurally, a Loop is closer to a cron-triggered agent loop than a graph: a scheduled or event-triggered entry point, a bounded task, and — critically — a human review point before anything ships. That design mirrors the pattern we detail in our guide to Claude Code's official Loops feature for scheduling agent runs, and the broader discipline of loop engineering for coding agents: a well-scoped, retryable unit of work with a clear stop condition beats an open-ended autonomous agent every time reliability matters more than novelty.
The sharpest reply in the thread came from Max Weinbach, an analyst at Creative Strategies: "what the fuck is a graph — man just type stuff and hit enter it's not that deep." It's a deliberately blunt take, but it names the real fault line in this debate — not graphs versus loops as technical structures, but structure-for-its-own-sake versus structure-only-when-earned.
The loop camp's argument, in its strongest form:
The graph camp's argument, in its strongest form:
Both are correct, for different task shapes. The mistake — which several commenters called out directly — is assuming one pattern generalizes to every agentic workload.
The most cited reply in the thread, from David K (creator of the XState state-machine library), cut straight past the graphs-vs-loops framing entirely: "State machines in 2 minutes... First it was loops. Now it's graphs. Next month it'll be something else. Here's the thing: we're constantly rediscovering decades-old software engineering patterns and repackaging them as innovations." It's the single most upvoted take in the thread (76 fire-emoji reactions) and it's hard to argue with.
Graph-based orchestration for agents is, structurally, a state machine — nodes are states, edges are transitions, and conditional edges are guard clauses. LangGraph's own documentation describes itself in exactly those terms. A Linear Loop is, structurally, a cron job with an LLM step and a human-approval gate — a pattern that predates LLMs by decades in CI/CD and workflow automation tooling. Neither "graph" nor "loop" is a novel invention specific to AI agents; both are established software engineering primitives, rebranded because the execution step inside each node or iteration now happens to call an LLM instead of deterministic code.
That reframe matters practically: instead of asking "should my agent system use graphs or loops," the more useful engineering question is the one teams have always asked when choosing between a state machine and a simple retry loop — does my workflow have more than a handful of branching states that need independent inspection and resumability? If yes, reach for graph-style orchestration. If no, a loop with good logging and a human checkpoint is simpler, cheaper, and easier to debug, which is exactly the philosophy behind the council of high-intelligence multi-LLM deliberation pattern we've covered — multiple agents coordinating through a defined structure only where the task actually demands it.
For most teams shipping agentic features in 2026, the decision tree is simpler than the X thread makes it sound:
None of these require picking a side in a Twitter argument. They require matching the orchestration pattern to the actual shape of the workflow — advice that was true for state machines in 2005 and remains true for agent loops and graphs in 2026.
Sources: DeepLearning.AI · Linear — Introducing Loops · X posts from Andreas Kollegger's course promotion, Karri Saarinen, Jori Lallo, Cristina Cordova, Harrison Chase, Max Weinbach, and David K (XState), July 2026.
Quotes and reaction counts reflect X posts as captured on July 21, 2026. Course and product details are subject to change by DeepLearning.AI and Linear after publication.
