Loading video...

Video Failed to Load

Go Home

the loop is not the agent it is one layer of the system LOOP vs GRAPH vs HARNESS ENGINEERING LOOP ENGINEERING controls repetition turns retries budgets exits success checks no progress use durable execution when the run must survive failure → GRAPH ENGINEERING controls topology nodes edges state branches...

50,189 views • 2 months ago •via X (Twitter)

16 Comments

Nurvia's profile picture
Nurvia2 months ago

The model is not the system. That is the lesson most of the teams learn too late during their journey.

elune's profile picture
elune2 months ago

fr the model is just one player the setup decides how the team performs

Nurvia's profile picture
Nurvia2 months ago

Exactly. The setup is the coach. The model is just the player.

elune's profile picture
elune2 months ago

🫡🫡

rari's profile picture
rari2 months ago

controls the blast radius is the best definition of harness engineering

elune's profile picture
elune2 months ago

yeah a good harness means one weird move stays one weird move

Jordan Lee's profile picture
Jordan Lee2 months ago

Everyone talks about models. Few talk about the engineering layer that makes them useful.

解意 JIE YI's profile picture
解意 JIE YI2 months ago

把 agent 等同于 while-loop 是当前最大的认知偏差。真正可运维的系统必须显式建模拓扑(节点、边、状态、handoff)并用 harness 限制工具与内存边界,否则 debug 只能靠猜。

Saman Ahmed's profile picture
Saman Ahmed2 months ago

Most people debug the model. The real failure is usually somewhere in the system around it.

TTD 🇮🇩's profile picture
TTD 🇮🇩2 months ago

Agreed

banhbao2k14's profile picture
banhbao2k142 months ago

loop as a layer makes sense, but how does it coordinate with the graph layer?

unicode's profile picture
unicode2 months ago

if i were a beginner, the first thing I'd do is learn about loops

Daniel Estrada's profile picture
Daniel Estrada2 months ago

The loop is the easy part. I wasted months polishing retries while the mess lived in permissions and what the agent could actually touch. When a long run goes sideways for you, which layer do you open first?

Dipanshu Kushwaha's profile picture
Dipanshu Kushwaha2 months ago

That's a great explanation! It really clarifies how the loop fits into the bigger picture. Well explained.

Maya Builds with AI's profile picture
Maya Builds with AI2 months ago

说得挺对,loop只是agent里最基础的一层,很多人以为写个while循环就是agent了🤔

pearson's profile picture
pearson2 months ago

standard prompt engineering is officially getting old

Related Videos

FIVE LAYERS OF AGENT ENGINEERING, EACH ONE WRAPS THE ONE BELOW IT. IF YOU SKIP LAYER 2, YOUR LAYER 5 WILL LOOK BROKEN WHEN IT IS ACTUALLY JUST STANDING ON NOTHING. for weeks i debated harness vs loop vs graph like they were competing choices. then a stack diagram made the shape obvious. they are not choices. they are floors. 01 | prompt engineering. the message. unit of work: one input. inputs are role, instructions, examples, format. output is a single raw response. 02 | context engineering. the memory. unit of work: what stays in the window. a curator selects, compresses, and drops from query, docs, memory, prior turns, and tool outputs before the prompt runs. 03 | harness engineering. the machine. unit of work: the machine itself. gather (context + prompt) → LLM → tools or sub-agents → verifier → final response. the article calls this the operating environment. 04 | loop engineering. the system. unit of work: the run. goal + success criteria + max iterations + budget + completion check wrap around one harness pass. failed pass appends results to context and retries. 05 | graph engineering. the topology. unit of work: the graph run. goal + nodes + edges + state schema. graph routes to agent nodes, tool nodes, or human approval. a reviewer node with a different model and fresh context checks the final answer. the wrapping is the whole point. layer 5 assumes layer 4 works. layer 4 assumes layer 3 works. skip layer 2 and layer 3's verifier keeps failing without a clear reason. this is why swapping the model is a one-day project and swapping the stack is a quarter. the model is the commodity. the five layers around it are the engineering. full three-layer breakdown of the top of the stack (harness, loop, graph) in the post below.

kocer

31,198 views • 1 month ago

Loops vs. Graphs, clearly explained! loops are great, and the ceiling is one you can watch turn: a loop is a gear. it produces, checks, corrects, and comes back around. after six turns you have one job, done very well. after six hundred turns you still have one job, done very well. the teeth are perfect. they are touching nothing. Graph engineering fixes this by moving the decision up a layer: not how well one gear turns, but what it is meshed into. you need both, and here is the sentence that resolves the whole confusion: the loop lives inside a node. the graph lives between them. ↳ inside one unit: produce, check, correct, repeat until green ↳ between units: split, fan out, merge, gate, send back Prompts → Context → Harness → Loops → Graphs the loop does not go away when you build a graph. it moves inside, and now there are three of them turning at once on three things you would never have thought to run. the trick is being selective about what becomes a node. only spend a model where judgment lives. merging, ranking, deduping and schema checks are edges, and edges are code. free, instant, and they cannot be argued out of a verdict. one thing to know before you scale it. a loop that cannot fail is not a loop, it is a repeat with a bill attached. ↳ the test suite exits 0 is a check. the diff touches only the files in the plan is a check ↳ the output looks good, the model says it is confident, no errors were raised, none of those are checks that last one catches careful people. absence of an error is not evidence of correctness, and a loop built on it will confidently repeat a mistake until the budget runs out, with a clean log the whole way. and the one that eats whole nights: when a unit fails, return that unit, not the batch. send back four slices because one failed and you have just rewritten three correct ones. do it twice in a run and the run never converges. below i have quoted my full guide on graph engineering. it covers the three topologies, the verifier patterns, and where the gate should actually open. save this and read it below ↓

Hanako

32,701 views • 18 days ago

Harness vs. Graphs, clearly explained! a harness is great, and most people think it is the whole thing: retries, timeouts, a sandbox, a log, the context it assembles before every call. all of that is real work, and all of it wraps exactly one call. run it a hundred times and you have one call, made very safely, a hundred times. Graph engineering fixes this by moving the decision up a layer: not how safely one call is made, but which calls exist to be made at all. you need both, and here is the sentence that resolves the whole confusion: the harness is everything around one call. the graph is everything between them. ↳ around one call: retry, timeout, sandbox, log, assemble the context, hand back a result ↳ between calls: split, fan out, merge, gate, send back Prompts → Context → Harness → Loops → Graphs the harness does not go away when you build a graph. it moves under each node, and now there are five of them, each wrapping a call you would never have made by hand. the trick is knowing which layer a failure belongs to. turn a piece off and run it again. if the call still works, it was the harness. if the wrong step runs at all, it was the graph. people spend weeks hardening a harness around a node that should not have existed. one thing to know before you scale it. most of what people call their agent is a harness with a chat box on it. ↳ it retries, it times out, it logs, it assembles context, it holds one call up beautifully ↳ it has never once decided that a second call should exist, and that is the entire difference that last one catches careful people. a harness that never fails is not evidence the system is right. it is evidence one call went well, which is the smallest possible claim. and the one that eats whole nights: a harness cannot save you from the wrong step running. you can retry a bad decision three times with a clean log and perfect isolation, and all you bought was three copies of it. below i have quoted my full guide on graph engineering. it covers the three topologies, the verifier patterns, and where the gate should actually open. save this and read it below ↓

Hanako

51,536 views • 23 days ago

Loops vs. Graphs, clearly explained! loops are great, and they have a ceiling you can watch happen: a loop goes around. it produces, checks, corrects, and goes around again. after six passes you have one job, done very well. after six hundred passes you still have one job, done very well. Graph engineering fixes this by moving the decision up a layer: not how well one job gets done, but which jobs exist to be done at all. you need both, and here is the sentence that resolves the whole confusion: the loop lives inside a node. the graph lives between them. ↳ inside one unit: produce, check, correct, repeat until green ↳ between units: split, fan out, merge, gate, send back Prompts → Context → Harness → Loops → Graphs the loop does not go away when you build a graph. it moves inside, and now there are three of them running at once on three things you would never have thought to run. the trick is being selective about what becomes a node. only spend a model where judgment lives. merging, ranking, deduping and schema checks are edges, and edges are code. free, instant, and they cannot be argued out of a verdict. one thing to know before you scale it. a loop that cannot fail is not a loop, it is a repeat with a bill attached. and the check people write is almost always the wrong kind. ↳ the test suite exits 0 is a check. the diff touches only the files in the plan is a check ↳ the output looks good, the model says it is confident, no errors were raised, none of those are checks that last one catches careful people. absence of an error is not evidence of correctness, and a loop built on it will confidently repeat a mistake until the budget runs out, with a clean log the whole way. and the one that eats whole nights: when a unit fails, return that unit, not the batch. send back four slices because one failed and you have just rewritten three correct ones. do it twice in a run and the run never converges. below i have quoted my full guide on graph engineering. it covers the three topologies, the verifier patterns, and where the gate should actually open. save this and read it below ↓

Hanako

128,779 views • 29 days ago