graphslice · ai-agents · agent-loops · code-graph
Are we still talking loops, or did we shift to graphs yet?
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.
On this page
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), 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 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: the minimal connected subgraph that answers one question, and nothing else.
> 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, 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?