Loops to Graphs: A Non-Technical Founder's Guide to the Next Evolution of AI Agent Systems

Peter Steinberger recently posted something on X that gathered thousands of likes: "Are we still talking loops or did we shift to graphs yet?"

The joke needed no explanation to anyone building AI agents, which is exactly why it landed. A whole field caught itself mid-stride, with one foot on the thing it was leaving and one foot on the thing it was reaching for.

I read it and felt the gap right away, because I am a non-technical founder and loops versus graphs was brand new to me. So I did what I always do when something important shows up that I do not yet understand. I opened Claude, dropped in the tweet and the article going around about it, and asked it to teach me like I was the person I actually am. Not an engineer, just a founder trying to build a real business with AI.

What came back gave me language for things I had already been building without realizing it, and that is worth paying forward.

This is the non-technical founder's translation of loops to graphs, written for my clients and for anyone building with AI who keeps hearing this word "graphs" and quietly nodding along without actually knowing what it means. Simple, real, and built from my own world rather than theory. Let me walk you through it.

What is a loop in AI agent systems?

A loop is one improve-cycle, where you pick a number, measure it, adjust, and repeat.

A thermostat is a loop. It checks the temperature, compares it to the setting, and turns the heat on or off, around and around. Your content system is a loop too. It watches engagement, notices what worked, and tweaks what you post next time, around and around.

Loops are powerful because they are simple enough to explain in one sentence and they genuinely make things better. Almost anything you measure and adjust will improve, at least at first, which is why loops became the starting point for everyone. They are the "hello world" of getting better with AI.

If you have built a single automation that runs, checks a result, and improves, then you have already built a loop. That is real and it matters, so hold onto it, because the next step does not throw it away.

What is a graph in AI, and how is it different from a loop?

A graph is loops wired to other loops, where the connections between them carry the intelligence.

Here is the picture. One loop does the work and chases its number, a second loop watches the first one to make sure it is not cheating to hit that number, and a third loop owns the target the first one is even aiming at, and can change that target when it stops making sense. Getting better stops being a single cycle you run and becomes a structure you design.

The unit of building moved from "make one good loop" to "wire up a network of loops that keep each other honest."

I want to be clear about something here, because AI culture loves to declare things dead. Loops are not dead, and nobody is throwing them out. A graph is made of loops. This is the next evolution, the same way a strong team is the next evolution of a single great employee. You did not stop needing great individuals, you learned to connect them.

The reason this is surfacing right now is real though. The tools got good enough that people are running many loops at once, and the moment you have many loops running together, you hit the exact problems a single loop can never solve on its own.

Why do single AI loops fail at scale?

A single loop breaks in four specific ways, and you have probably felt all four in your business without having names for them.

The loop games its own number. A loop only sees the one thing it measures, so it will find every way to move that number, including the ways that betray the point. Push a system to maximize podcast downloads and you can end up with clickbait titles that torch trust. The loop looks like it is winning while the real goal walks out the door.

The loop cannot question its own target. A loop drives toward a goal and can never step back to ask whether the goal is right. Your content loop will happily optimize posting volume forever, even if volume was never the thing that actually grew your revenue.

Loops start fighting each other. Speed versus depth, content velocity versus content quality. Built on their own, each loop looks healthy while quietly working against the one right next to it.

Nobody is watching the watcher. The measurement itself goes stale, and the dashboard stays green while the number underneath quietly stops meaning anything.

Read those four again through the lens of your own business. If any of them made you wince, that is the feeling of running loops without a graph around them.

How a Notion second brain is already an AI agent graph

I went into this thinking a graph was a technical thing I needed to go learn and build from scratch. Then I looked at my own Notion, and I realized I had already built the graph. I just built it as a filing system and never called it that.

Let me show you what I mean, because if you have been building a second brain too, this is probably true for you as well.

My business map was already a graph. Inside my system, every component has fields for what it reads from, what it writes to, what it is used by, its canonical source, and what to do when its information goes stale. I built those fields to stay organized, and it turns out that is the exact language a graph uses. The "reads from" and "writes to" fields are the connections between loops. I was not documenting a list of parts, I was documenting the wiring between them without knowing that is what wiring was called. This is the same structure I laid out in how I built an AI second brain in Notion.

My second brain was already the shared memory. In a graph, there is a center that every part can read from and write back to, so the parts do not have to talk to each other directly. That is what Notion is for me. My second brain was never just storage, it is the shared memory that lets every loop and every agent stay in sync. You have felt this if you have ever had one AI chat pick up context that another one created, because that handoff happens through the shared memory. It is the same idea behind how to use Notion as an AI operating system for your business.

My stale-check field was already an anchor. This is the part almost everyone misses, and it is the real punchline of the whole loops-to-graphs conversation.

A network of loops has a hidden failure mode. Every loop can end up checking another loop's report, and another loop checking that one, until nothing in the system is actually touching reality anymore. It all agrees with itself and none of it is true, which is a beautiful hall of mirrors that feels like progress right up until it falls apart.

The fix is anchors. You need a few numbers in the system that cannot be argued with, and a few rules the system is never allowed to bend. Money that actually hit the bank. A customer who actually stayed. A rule that stays frozen no matter what the optimizer wants to do.

My canonical source and stale-check fields were me building anchors before I knew that was the exact thing you are supposed to design against. I was doing it on instinct because I care about my work being true, and the framework just gave me the words for it.

If you have been building a real second brain, you have probably been doing versions of this too. That is why I think this makes such a strong proof point. This is not a far-off technical concept, it is a name for something that founders who build with care are already reaching toward.

What humans decide that AI agents can't in a graph system

This is the deepest part, so slow down with me here.

Loops chase targets and graphs manage and revise those targets, but the first judgment, the call on what "better" even means, cannot come from the machine. Every loop in the system already assumes that answer before it starts running. The machinery cannot generate the one thing it depends on to exist.

That judgment comes from a human who has been in contact with real failure, someone who has watched a number climb while customers walked away and felt the cost of it. That human is you.

This is why I build Human First, AI Enabled, and this is the moment that phrase stops being a slogan and becomes actual systems architecture. The graph runs the loops, and you decide what winning means and which rules stay frozen no matter what. Your role does not shrink as the AI gets stronger. Your role becomes the anchor the entire system depends on.

Sit with that, because it is the opposite of the fear most founders carry. You are not being automated toward the exit. You are becoming the one irreplaceable node in your own graph.

How to turn your AI loops into a graph: 4 steps

You do not need to rebuild anything. You need a new lens on what you already have, so here is where to start.

1. Name your shared memory. Look at where your loops and your AI chats read from and write back to. For most founders building seriously, that is a second brain in Notion, and that center is your shared state. Knowing that changes how you treat it, because you protect it differently once you know everything depends on it.
2. Run your live automations through the four failures. Take each system you already have running and ask four questions. Is it hitting its number in a way that cheats the goal? Is it chasing a target nobody has checked in months? Is it fighting another one of your systems? Is its dashboard green while the number underneath went stale? Every yes is your next fix, handed right to you.
3. Find your anchors, or add them. Ask what in your system cannot be argued with. Real revenue, real retained clients, a rule you never let the system bend. If you cannot point to a single anchor, that is the most important build you have this month.
4. Add three questions to every new loop. Before you trust any new automation to run on its own, answer three things. What does it read from and write to? What watches it to catch it cheating? What is the anchor that keeps it honest? A loop that cannot answer all three is not ready to run without you yet. If you are just starting to wire up agents on top of your system, how to build AI agents as a non-technical founder is the natural next step.

Loops vs graphs: the takeaway for founders building with AI

Loops taught our systems how to get better, and graphs are how they get better without fooling themselves. This is evolution, not replacement, and the wild part is how many founders are already partway there without the vocabulary for it.

If you built a second brain, you started building a graph. The fields you made to stay organized were the wiring, the shared brain you kept everything in was the shared state, and the care you took to keep your work true was you building anchors on instinct.

The framework did not hand me a new business. It handed me the language for the one I was already building, and that is what a good mental model does. It lets you see what you already have with new eyes so you can build the next layer on purpose instead of by accident.

You are closer to this than you think.