---
title: "Are we still talking loops, or did we shift to graphs yet?"
description: "The godfather of the openclaw scene dropped a six-word tweet about loops and graphs, and 2.5 million people looked up. He didn't mean us. Probably. Here's what a graph-shaped question could mean, and why the arrow points our way."
date: 2026-07-19
tags:
  - graphslice
  - ai-agents
  - agent-loops
  - code-graph
draft: false
---

At 00:34 on a Friday, a six-word tweet went up and two and a half million
people looked at it. No thread. No diagram. No product. Just a question, thrown
at the timeline like a coin into a fountain:

> Are we still talking loops or did we shift to graphs yet?

*Peter Steinberger ([@steipete](https://x.com/steipete)), 18 July 2026 · 2.5M views · 362 reposts*

It got 1,200 replies. We read a good chunk of them. Nobody agreed on what he
meant, which is exactly why we can't stop thinking about it.

## Who's asking

If you've spent any time with the *openclaw* crowd, 
the people who spend their days pointing at a coding agent in their own repo and
yelling **go**, you know what's going on here. Peter's not selling anything with that tweet.
That's what gives it weight. When the godfather of the loop starts publicly wondering whether the loop was ever the
whole story, you don't scroll past it. You screenshot it.

So we did. And then we did the thing you're not supposed to do with an ambiguous
tweet: we tried to figure out what it *meant*.

## What could it mean?

Honestly? Nobody knows, including the author, probably. "Graphs"
is one of those words that's exactly specific enough to feel like a thesis and
exactly vague enough to be four different ones. Read the replies and you'll find
at least these camps, each convinced they're the one he meant:

| The reading | "Graphs" means… | The itch it's scratching |
| --- | --- | --- |
| **Workflow graphs** | Wire the agent's steps as a DAG instead of a `while` loop | The loop wanders; a graph is a plan you can see |
| **GraphRAG** | Retrieve over an entity graph, not a pile of embeddings | Vector search returns *nearby*, not *related* |
| **Knowledge graphs** | Give the model a structured world model to reason over | Text is lossy; structure survives |
| **Code graphs** | Feed the agent how the software actually connects | The answer lives *between* the files |

Four readings, one shape. Notice what they have in common: every single one is
a quiet admission that **the loop, on its own, is running blind.**

## The loop was never the problem. The blindfold was.

Let's be fair to the loop. The loop is *great*. Model calls a tool, reads the
result, decides what to do next, goes again... that inner engine is most of why
2025 felt like magic. Nobody sane is proposing we throw it out.

But a loop is an engine, and an engine is not a map. Point a tireless agent at a
million-line C# solution and tell it to loop, and what you've built is something
that can `grep`, guess, and `grep` again, very fast, forever and won't ever ship. 
It doesn't know that `IPaymentProcessor` has four implementations and one of them 
only shows up in a DI container three projects away. It finds that out the expensive 
way, by looping into the wall until the wall gives.

That's the itch under Steinberger's question. "Did we shift to graphs yet?" is
the polite version of *how long are we going to let these things run in circles
because we never handed them the map?*

## We've been the graph the whole time

We'll say the quiet part, because it's the only part we're qualified to say: for
GraphSlice, this was never a "shift." There was no loop era we're now leaving.
We started with a graph.

GraphSlice is a compiler-grade
[semantic code graph](/blog/why-ai-assistants-should-query-architecture/) of
your C# solution. Real types, methods, references, inheritance, call edges,
package boundaries. It's the exact map the compiler builds on every build and then
throws away. We keep it. And we don't hand the agent the whole thing, because a whole map without pointers just bloats your context. Instead, we hand the agent
a [slice](/blog/what-is-a-context-slice/): the minimal connected
subgraph that answers *one* question, and nothing else.

```text
> what breaks if I change IPaymentProcessor?

IPaymentProcessor (interface, Billing.Core)
├── implemented by StripeProcessor       (Billing.Stripe)
├── implemented by InvoiceProcessor      (Billing.Invoicing)
├── injected into CheckoutService..ctor  (Web.Checkout)
└── mocked in PaymentProcessorTests      (Billing.Tests)
```

Put that in front of the loop and the loop stops being a blindfolded sprint. It
becomes what it was always supposed to be: a fast engine with its headlights on.
The graph doesn't replace the loop. It's what the loop should have been running
*over* the entire time. And because it's served over
[MCP](https://modelcontextprotocol.io), any agent already stuck in a loop can
ask for the map without changing a thing about how it loops.

## So what did he mean?

Honestly? He probably didn't mean us. He didn't @ us, he didn't link us, and a
tweet that vague is a Rorschach test. Everyone selling a graph this week is
going to read it as a horoscope written personally for their launch. We know how
that looks. We're doing it right now, on purpose, with a wink.

But here's the thing about tea leaves: sometimes the arrow really is pointing
somewhere. "Are we still talking loops or did we shift to graphs yet?" is not a
neutral question. It's a question with a *direction* baked into it, and the
direction is away from *run it again and hope* and toward *hand it the map.*
Six words, and every reasonable reading of them ends up somewhere adjacent to
the thing we've been quietly shipping since before it was a tweet.

So, are we still talking loops, or did we shift to graphs yet?