Agent Harness, Loop, and Graph Engineering: The Distinction?

One in all your colleagues asserts that “we require improved loop engineering,” but the elemental difficulty lies throughout the harness itself. Others could create graphs with 40 nodes earlier than they observe how the agent executes a given activity at a single time. Does this sound like one thing you may have encountered earlier than?

This ongoing confusion surrounding agent harness engineering, loop engineering, and graph engineering is changing into fairly widespread. All three work with the identical mannequin and contain some sort of recurring exercise. Nevertheless, they deal with distinct issues and mixing them can turn into expensive as quickly as an agent works with actual APIs or information.

What Do These Three Phrases Really Imply?

Right here’s how I’d clarify it to you underneath a minute:

• Harness engineering refers back to the course of of making an atmosphere the place the mannequin will perform.
• On the opposite aspect, loop engineering is answerable for the method design in regards to the actions and suggestions cycle.
• Graph engineering is aimed toward making clear the configuration of the method by way of nodes, branches, merges, and managed loops.

So, the sequence that we should comply with when one thing breaks down in manufacturing is environment-feedback-flow.

An unprocessed mannequin is incapable of writing onto a file system. It doesn’t have the aptitude of retaining state from earlier classes, nor can it boot after a failure. All of that is depending on what’s constructed round it. That is the explanation why the stack is becoming layers. That is the explanation why the dialogue exploded on Twitter in July 2026. Peter Steinberger posed a query that reverberated in which means:

Agent Harness Engineering: The Basis Layer

The agent is outlined within the easiest method as a mannequin mixed with a harness. A harness is recognized as all the things that’s current outdoors the mannequin, similar to code, configuration, and execution logic.

To check the idea, we will delete the mannequin within the structure diagram. What stays is the harness. The harness contains instruments, storage, middleware, data retrieval, logging, and retry processes.

The identical foundational mannequin is given to 2 groups. Crew one is supplied with clear instruments, secure working atmosphere, and observable knowledge. Crew two receives poor directions and an unstable API wrapper

A typical harness usually incorporates:

• Contextual data: steering, gathered knowledge, dialogue historical past, approaches to the duty
• Execution mechanisms: APIs, net browsers, command line interfaces, code execution language, extra
• Storage and retrieval: information, state of execution, classes, git historical past
• Management over execution: time to reside, retries, spending limits, routing of fashions, gates of approval

Make use of harness each time an agent is unable to do a sure activity or can not decide up from the place it left off. That is additionally relevant when the agent’s data shouldn’t be constant or is misplaced. Anthropic realized this with its long-running coding agent. Simply compacting the context shouldn’t be enough for preserving the agent on monitor. The profitable implementation must be a full-system resolution with an initializer, progress information, or git historical past. A brand new context ought to simply decide up the place it was left earlier than.

Loop Engineering: Designing the Suggestions Cycle

Every system using instruments operates with a loop of kinds already in-built. By making the decision after which conducting the motion and submitting the end result again to repeat with a ground-up cycle, one has constructed a cycle.

The time period ‘loop engineering’ comes into play when one makes use of extra cycles deliberately on an ongoing foundation.

As Boris Cherny, head of Claude Code at Anthropic, stated in an interview in June of 2026, “I don’t immediate Claude anymore, I activate loops that immediate Claude. All I do is create loops!”. Merchandise like Claude Code and OpenAI are actually releasing, for instance, instructions similar to /aim and /loop, making it evident. Now, let’s take a look at a barebones loop verifier:

def run_loop(agent, activity, max_attempts=5):
    for try in vary(max_attempts):
        output = agent.act(activity)
        handed, suggestions = confirm(output, activity.spec)
        if handed:
            return output
        activity.context.append(suggestions)  # particular, not obscure
    return escalate_to_human(activity, output)


def confirm(output, spec):
    # deterministic verify beats "does this look proper?"
    if spec.sort == "code":
        return run_tests(output), "exams failed: see diff"
    return validate_schema(output, spec.schema)

Word what’s absent right here: no “proceed refining till it appears proper”. The method concludes with proof that exams are handed, mannequin confirmed and never primarily based on certainty of the mannequin. That is the place the excellence lies.

Loops can have completely different definitions, which might be categorized into 4 necessary varieties:

• Flip-based: a cycle acts on each consumer command
• Purpose-based: a loop continues its operation till reaching a satisfying finish.
• Time-based: a cycle performs an motion as scheduled.
• Proactive: the system executes an motion with out consumer intervention.

A system that fixes bugs is one that’s primarily based on a objective. Then again, a system that outputs each day updates depends on schedule precisely. Due to this fact, when grouped collectively, all types of loop engineering hypotheses can lead you to inaccurate conclusions.

Graph Engineering: Making the Management Circulation Specific

The inquiry relating to the graph is completely different. It’s not about “what’s being completed by the agent”, however fairly “what’s permitted to proceed onward”.

A loop might be characterised as being a graph comprising precisely one node that cycles again onto itself. Reasonably than discarding loops, one makes use of them for creating the graph. Every node of the graph executes its personal loop, Uncover, Plan, Execute, and Confirm simply on the stage of that node. Graph engineering doesn’t substitute loop engineering, however fairly it incorporates loops into the graph, including routing on prime of that.

The next is an instance of minimal graph following the LangGraph paradigm as utilized in a research-brief workflow:

from langgraph.graph import StateGraph, END

graph = StateGraph(BriefState)
graph.add_node("researcher", fan_out_sources)   # runs in parallel
graph.add_node("author", draft_from_notes)      # sees clear notes solely
graph.add_node("reviewer", check_accuracy)      # recent context, no bias

graph.add_edge("researcher", "author")
graph.add_conditional_edges(
    "author", lambda s: "reviewer",
)

graph.add_conditional_edges(
    "reviewer",
    lambda s: END if s.permitted else "author",  # loop again on failure
)

This reviewer node features underneath a brand new context. The reviewer node can view the finished temporary and the accuracy measure, however not the environment friendly processing it took to provide it. Due to this fact, the reviewer has recent views and never the eyes that did the drafting.

Palms-On Process: Repair Three Bugs Three Totally different Methods

You might have learnt concerning the three layers theoretically, however it’s time to take some sensible steps. You need to execute the next activity utilizing all three strategies: first utilizing the harness-only structure, then with the loop construction, after which with the graph structure.

Create the Damaged Mini-Repo

Create a brand new listing the place you’ll put your three damaged information. Every of these information may have one bug and one take a look at created by pytest:

# calc.py
def divide(a, b):
    return a // b  # bug: integer division, not float


# test_calc.py
from calc import divide


def test_divide():
    assert divide(7, 2) == 3.5


# strings_utils.py
def reverse_words(sentence):
    return sentence.cut up()[::-1]  # bug: returns a listing, not a string


# test_strings_utils.py
from strings_utils import reverse_words


def test_reverse_words():
    assert reverse_words("whats up world") == "world whats up"


# dates_utils.py
from datetime import date


def days_between(d1, d2):
    return (d2 - d1).days + 1  # bug: off by one


# test_dates_utils.py
from datetime import date
from dates_utils import days_between


def test_days_between():
    assert days_between(date(2026, 1, 1), date(2026, 1, 10)) == 9

Set up what you want, then affirm all three exams at the moment fail:

pip set up pytest anthropic
pytest -q

Add a tiny mannequin wrapper each spherical will reuse:

# mannequin.py

import os
from anthropic import Anthropic


shopper = Anthropic(api_key=os.environ["ANTHROPIC_API_KEY"])


def call_model(immediate: str) -> str:
    resp = shopper.messages.create(
        mannequin="claude-sonnet-5",
        max_tokens=1024,
        messages=[
            {"role": "user", "content": prompt}
        ],
    )

    return resp.content material[0].textual content

Output:

Spherical 1: Harness Engineering

On this stage, the agent is given entry to some instruments and talents like file writing and studying and working exams, however no retry or routing processes are allowed. The operation might be carried out as soon as for every file, and the method have to be documented.

# round1_harness_only.py

import subprocess
from mannequin import call_model


FILES = ["calc.py", "strings_utils.py", "dates_utils.py"]


def run_tests(file):
    r = subprocess.run(
        ["pytest", f"test_{file}", "-q"],
        capture_output=True,
        textual content=True,
    )
    return r.returncode == 0, r.stdout + r.stderr


def fix_once(file):
    handed, log = run_tests(file)

    if handed:
        return True

    code = open(file).learn()

    immediate = (
        f"This code fails its take a look at:n{code}nn"
        f"Take a look at output:n{log}n"
        "Return solely the mounted code, nothing else."
    )

    open(file, "w").write(call_model(immediate))

    handed, _ = run_tests(file)

    return handed


for f in FILES:
    print(f, "mounted:", fix_once(f))

Output:

Spherical 2: Loop engineering

The context have to be returned to the earlier stage and now the verification course of might be supplied by using loops, which won’t enable the agent to cease the operation after the primary failure.

# round2_loop.py

from mannequin import call_model
from round1_harness_only import FILES, run_tests


def run_loop(file, max_attempts=5):
    for try in vary(max_attempts):
        handed, log = run_tests(file)

        if handed:
            return try

        code = open(file).learn()
        immediate = f"Repair this failing code:n{code}nnTest failure:n{log}"

        open(file, "w").write(call_model(immediate))

    return None


for f in FILES:
    makes an attempt = run_loop(f)

    print(
        f,
        "mounted in",
        makes an attempt,
        "makes an attempt" if makes an attempt shouldn't be None else "failed",
    )

Output:

Spherical 3: Graph engineering

The step requires resetting the context of the experiment. Now, a number of nodes are created for 3 information, and the verification course of is carried out for every of them. When finishing the experiment, the efficiency of the nodes might be verified with the precise verify of the duties accomplished.

# round3_graph.py

import subprocess
from concurrent.futures import ThreadPoolExecutor

from round1_harness_only import FILES
from round2_loop import run_loop


def coder_node(file):
    return file, run_loop(file)


def reviewer_node():
    r = subprocess.run(["pytest", "-q"], capture_output=True, textual content=True)
    return r.returncode == 0


with ThreadPoolExecutor(max_workers=3) as pool:
    outcomes = record(pool.map(coder_node, FILES))

print(outcomes)
print("full suite passes:", reviewer_node())

Output:

What every layer purchased

Conclusion

Harness engineering creates the machine by which the mannequin works. Loop engineering allows us to work in an iterative and verifiable method. Graph engineering clarifies the difficult execution path. Not one of the three strategies cancels the usage of the opposite strategies. If there are many fantastically drawn graphs however harnesses lose their state, it doesn’t make sense. The perfect harness might be rendered ineffective if there aren’t any stopping guidelines.

Be sure that to design all three. Then it is possible for you to to create a system that may be debugged fairly than an indication that may crash the primary time it’s used.

Learn extra: Graph Engineering for AI Brokers: Past the Single-Agent Loop

Incessantly Requested Questions

Information Science Trainee at Analytics Vidhya
I’m at the moment working as a Information Science Trainee at Analytics Vidhya, the place I give attention to constructing data-driven options and making use of AI/ML strategies to resolve real-world enterprise issues. My work permits me to discover superior analytics, machine studying, and AI purposes that empower organizations to make smarter, evidence-based selections.
With a robust basis in laptop science, software program improvement, and knowledge analytics, I’m captivated with leveraging AI to create impactful, scalable options that bridge the hole between expertise and enterprise.
📩 It’s also possible to attain out to me at [email protected]