graphslice · ai-agents · agent-loops · code-graph
Are we still talking loops, or did we shift to graphs yet?
The godfather of the agentic 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. 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 lot of them. Nobody agreed on what he meant. That is exactly why we can't stop thinking about it.
Who's asking
If you've spent any time with the openclaw crowd, you know what's going on here. These are the people who point a coding agent at their own repo and yell go. Peter is not selling anything with that tweet. That's what gives it weight. When the godfather of the loop starts wondering, in public, 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 is specific enough to feel like a thesis and 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 | Run the agent's steps as a DAG, not 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 | Embeddings return nearby, not related |
| Knowledge graphs | Give the model structured facts 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. The 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 wants to 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. What you get is a machine
that can grep, guess, and grep again — very fast, forever — and never
ship. It doesn't know that IPaymentProcessor has four implementations, or
that one of them only appears in a DI container three projects away. It
learns that the expensive way: it loops 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 will we 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, calls edges
(CALLS), package boundaries. The compiler builds this graph on every build
and then throws it away. We keep it. And we don't hand the agent the whole
graph, because that just bloats the context. Instead, we hand the agent a
context 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 meant to be: a fast engine with its headlights on. The graph does not replace the loop. It is what the loop should have been running over the entire time. And because the graph is served over the Model Context Protocol (MCP), any agent already stuck in a loop can ask for it 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 will 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 does point somewhere. "Are we still talking loops or did we shift to graphs yet?" is not a neutral question. It has a direction baked in. The direction is away from run it again and hope, and toward hand it the graph. Six words, and every reasonable reading of them lands next 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?