---
title: "Are we still talking loops, or did we shift to graphs yet?"
description: "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."
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. 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 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](/blog/why-ai-assistants-should-query-architecture/) 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](/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 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)](https://modelcontextprotocol.io),
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?