One of your colleagues asserts that \u201cwe require improved loop engineering,\u201d yet the fundamental issue lies within the harness itself. Others may create graphs with 40 nodes before they observe how the agent executes a given task at a single time. Does this sound like something you have encountered before?<\/p>\n
This ongoing confusion surrounding agent harness engineering, loop engineering, and graph engineering is becoming quite common. All three work with the same model and involve some type of recurring activity. However, they address distinct problems and mixing them can become costly as soon as an agent works with real APIs or files.<\/p>\n
What Do These Three Terms Actually Mean?<\/h2>\n
Here\u2019s how I would explain it to you under a minute:<\/p>\n
- \n
- Harness engineering refers to the process of creating an environment where the model will function. <\/li>\n
- On the other side, loop engineering is responsible for the process design concerning the activities and feedback cycle. <\/li>\n
- Graph engineering is aimed at making clear the configuration of the process in terms of nodes, branches, merges, and controlled loops.<\/li>\n<\/ul>\n
So, the sequence that we must follow when something breaks down in production is environment-feedback-flow.<\/p>\n
An unprocessed model is incapable of writing onto a file system. It does not have the capability of retaining state from previous sessions, nor can it boot after a failure. All of this is dependent on what is built around it. This is the reason why the stack is changing into layers. This is the reason why the discussion exploded on Twitter in July 2026. Peter Steinberger posed a question that reverberated in meaning: <\/p>\n
\n![\"Social](\"https:\/\/cdn.analyticsvidhya.com\/wp-content\/uploads\/2026\/07\/image-1-09tepb.webp\")
<\/figure>\n<\/div>\nAgent Harness Engineering: The Foundation Layer<\/h2>\n
The agent is defined in the simplest way as a model combined with a harness. A harness is identified as everything that is present outside the model, such as code, configuration, and execution logic.<\/p>\n
To test the concept, we can delete the model in the architecture diagram. What remains is the harness. The harness includes tools, storage, middleware, information retrieval, logging, and retry processes.<\/p>\n
\n![\"Comparison](\"https:\/\/cdn.analyticsvidhya.com\/wp-content\/uploads\/2026\/07\/image-2-09tepb.webp\")
<\/figure>\n<\/div>\nThe same foundational model is given to two teams. Team one is provided with clean tools, stable working environment, and observable data. Team two receives poor instructions and an unstable API wrapper<\/p>\n
A typical harness generally contains:<\/p>\n
- \n
- Contextual information: <\/strong>guidance, gathered data, dialogue history, approaches to the task<\/li>\n
- Execution mechanisms<\/strong>: APIs, web browsers, command line interfaces, code execution language, more<\/li>\n
- Storage and retrieval:<\/strong> files, state of execution, sessions, git history<\/li>\n
- Control over execution:<\/strong> time to live, retries, spending limits, routing of models, gates of approval<\/li>\n<\/ul>\n
Make use of harness whenever an agent is unable to do a certain task or cannot pick up from where it left off. This is also applicable when the agent\u2019s information is not consistent or is lost. Anthropic realized this with its long-running coding agent. Just compacting the context is not sufficient for keeping the agent on track. The successful implementation should be a full-system solution with an initializer, progress files, or git history. A new context should just pick up where it was left before.<\/p>\n
Loop Engineering: Designing the Feedback Cycle<\/h2>\n
Each device utilizing tools operates with a loop of sorts already built in. By making the call and then conducting the action and submitting the result back to repeat with a ground-up cycle, one has constructed a cycle. <\/p>\n
The term \u2018loop engineering\u2019 comes into play when one uses additional cycles intentionally on an ongoing basis. <\/p>\n
As Boris Cherny, head of Claude Code at Anthropic, said in an interview in June of 2026, \u201cI don\u2019t prompt Claude anymore, I activate loops that prompt Claude. All I do is create loops!\u201d. Products like Claude Code and OpenAI are now releasing, for example, commands such as \/goal and \/loop, making it evident. Now, let\u2019s look at a barebones loop verifier:<\/p>\n
def run_loop(agent, task, max_attempts=5):\n for attempt in range(max_attempts):\n output = agent.act(task)\n passed, feedback = verify(output, task.spec)\n if passed:\n return output\n task.context.append(feedback) # specific, not vague\n return escalate_to_human(task, output)\n\n\ndef verify(output, spec):\n # deterministic check beats \"does this look right?\"\n if spec.type == \"code\":\n return run_tests(output), \"tests failed: see diff\"\n return validate_schema(output, spec.schema)<\/code><\/pre>\nNote what is absent here: no \u201ccontinue refining until it seems right\u201d. The process concludes with proof that tests are passed, model confirmed and not based on certainty of the model. This is where the distinction lies.<\/p>\n
Loops can have different definitions, which can be classified into four important kinds:<\/p>\n
- \n
- Turn-based:<\/strong> a cycle acts on every user command<\/li>\n
- Goal-based:<\/strong> a loop continues its operation until achieving a satisfying end.<\/li>\n
- Time-based:<\/strong> a cycle performs an action as scheduled.<\/li>\n
- Proactive:<\/strong> the system executes an action without user intervention.<\/li>\n<\/ul>\n
\n![\"Four](\"https:\/\/cdn.analyticsvidhya.com\/wp-content\/uploads\/2026\/07\/image-4-09tepb.webp\")
<\/figure>\n<\/div>\nA system that fixes bugs is one that is based on a purpose. On the other hand, a system that outputs daily updates relies on schedule accurately. Therefore, when grouped together, all forms of loop engineering hypotheses can lead you to erroneous conclusions.<\/p>\n
Graph Engineering: Making the Control Flow Explicit<\/h2>\n
The inquiry regarding the graph is different. It\u2019s not about \u201cwhat is being done by the agent\u201d, but rather \u201cwhat is permitted to continue onward\u201d.<\/p>\n
A loop can be characterized as being a graph comprising exactly one node that cycles back onto itself. Rather than discarding loops, one uses them for developing the graph. Each node of the graph executes its own loop, Discover, Plan, Execute, and Verify just at the level of that node. Graph engineering does not replace loop engineering, but rather it incorporates loops into the graph, adding routing on top of that.<\/p>\n
The following is an example of minimal graph following the LangGraph paradigm as used in a research-brief workflow:<\/p>\n
from langgraph.graph import StateGraph, END\n\ngraph = StateGraph(BriefState)\ngraph.add_node(\"researcher\", fan_out_sources) # runs in parallel\ngraph.add_node(\"writer\", draft_from_notes) # sees clean notes only\ngraph.add_node(\"reviewer\", check_accuracy) # fresh context, no bias\n\ngraph.add_edge(\"researcher\", \"writer\")\ngraph.add_conditional_edges(\n \"writer\", lambda s: \"reviewer\",\n)\n\ngraph.add_conditional_edges(\n \"reviewer\",\n lambda s: END if s.approved else \"writer\", # loop back on failure\n)<\/code><\/pre>\nThis reviewer node functions under a new context. The reviewer node can view the completed brief and the accuracy measure, but not the efficient processing it took to produce it. Therefore, the reviewer has fresh perspectives and not the eyes that did the drafting.<\/p>\n
\n![\"Comparison](\"https:\/\/cdn.analyticsvidhya.com\/wp-content\/uploads\/2026\/07\/image-6-09tepb.webp\")
<\/figure>\n<\/div>\nHands-On Task: Fix Three Bugs Three Different Ways<\/h2>\n
You have learnt about the three layers theoretically, but it is time to take some practical steps. You should execute the following task using all three techniques: first using the harness-only architecture, then with the loop structure, and then with the graph architecture.<\/p>\n
Create the Broken Mini-Repo<\/h3>\n
Create a new directory where you will put your three broken files. Each of those files will have one bug and one test created by pytest:<\/p>\n
# calc.py\ndef divide(a, b):\n return a \/\/ b # bug: integer division, not float\n\n\n# test_calc.py\nfrom calc import divide\n\n\ndef test_divide():\n assert divide(7, 2) == 3.5\n\n\n# strings_utils.py\ndef reverse_words(sentence):\n return sentence.split()[::-1] # bug: returns a list, not a string\n\n\n# test_strings_utils.py\nfrom strings_utils import reverse_words\n\n\ndef test_reverse_words():\n assert reverse_words(\"hello world\") == \"world hello\"\n\n\n# dates_utils.py\nfrom datetime import date\n\n\ndef days_between(d1, d2):\n return (d2 - d1).days + 1 # bug: off by one\n\n\n# test_dates_utils.py\nfrom datetime import date\nfrom dates_utils import days_between\n\n\ndef test_days_between():\n assert days_between(date(2026, 1, 1), date(2026, 1, 10)) == 9<\/code><\/pre>\nInstall what you need, then confirm all three tests currently fail:<\/p>\n
pip install pytest anthropic\npytest -q<\/code><\/pre>\nAdd a tiny model wrapper every round will reuse:<\/p>\n
# model.py\n\nimport os\nfrom anthropic import Anthropic\n\n\nclient = Anthropic(api_key=os.environ[\"ANTHROPIC_API_KEY\"])\n\n\ndef call_model(prompt: str) -> str:\n resp = client.messages.create(\n model=\"claude-sonnet-5\",\n max_tokens=1024,\n messages=[\n {\"role\": \"user\", \"content\": prompt}\n ],\n )\n\n return resp.content[0].text<\/code><\/pre>\nOutput:<\/strong><\/p>\n
\n![\"List](\"https:\/\/cdn.analyticsvidhya.com\/wp-content\/uploads\/2026\/07\/image-7-09tepb.webp\")
<\/figure>\n<\/div>\nRound 1: Harness Engineering<\/h3>\n
In this stage, the agent is given access to some tools and abilities like file writing and reading and running tests, but no retry or routing processes are allowed. The operation will be performed once for each file, and the process must be documented.<\/p>\n
# round1_harness_only.py\n\nimport subprocess\nfrom model import call_model\n\n\nFILES = [\"calc.py\", \"strings_utils.py\", \"dates_utils.py\"]\n\n\ndef run_tests(file):\n r = subprocess.run(\n [\"pytest\", f\"test_{file}\", \"-q\"],\n capture_output=True,\n text=True,\n )\n return r.returncode == 0, r.stdout + r.stderr\n\n\ndef fix_once(file):\n passed, log = run_tests(file)\n\n if passed:\n return True\n\n code = open(file).read()\n\n prompt = (\n f\"This code fails its test:\\n{code}\\n\\n\"\n f\"Test output:\\n{log}\\n\"\n \"Return only the fixed code, nothing else.\"\n )\n\n open(file, \"w\").write(call_model(prompt))\n\n passed, _ = run_tests(file)\n\n return passed\n\n\nfor f in FILES:\n print(f, \"fixed:\", fix_once(f))<\/code><\/pre>\nOutput:<\/strong><\/p>\n
\n![\"Test](\"https:\/\/cdn.analyticsvidhya.com\/wp-content\/uploads\/2026\/07\/image-8-09tepb.webp\")
<\/figure>\n<\/div>\nRound 2: Loop engineering<\/h3>\n
The context must be returned to the previous stage and now the verification process will be provided by utilizing loops, which will not allow the agent to stop the operation after the first failure.<\/p>\n
# round2_loop.py\n\nfrom model import call_model\nfrom round1_harness_only import FILES, run_tests\n\n\ndef run_loop(file, max_attempts=5):\n for attempt in range(max_attempts):\n passed, log = run_tests(file)\n\n if passed:\n return attempt\n\n code = open(file).read()\n prompt = f\"Fix this failing code:\\n{code}\\n\\nTest failure:\\n{log}\"\n\n open(file, \"w\").write(call_model(prompt))\n\n return None\n\n\nfor f in FILES:\n attempts = run_loop(f)\n\n print(\n f,\n \"fixed in\",\n attempts,\n \"attempts\" if attempts is not None else \"failed\",\n )<\/code><\/pre>\nOutput:<\/strong><\/p>\n
\n![\"Test](\"https:\/\/cdn.analyticsvidhya.com\/wp-content\/uploads\/2026\/07\/image-9-09tepb.webp\")
<\/figure>\n<\/div>\nRound 3: Graph engineering<\/h3>\n
The step requires resetting the context of the experiment. Now, several nodes are created for three files, and the verification process is performed for each of them. When completing the experiment, the performance of the nodes will be verified with the actual check of the tasks completed.<\/p>\n
# round3_graph.py\n\nimport subprocess\nfrom concurrent.futures import ThreadPoolExecutor\n\nfrom round1_harness_only import FILES\nfrom round2_loop import run_loop\n\n\ndef coder_node(file):\n return file, run_loop(file)\n\n\ndef reviewer_node():\n r = subprocess.run([\"pytest\", \"-q\"], capture_output=True, text=True)\n return r.returncode == 0\n\n\nwith ThreadPoolExecutor(max_workers=3) as pool:\n results = list(pool.map(coder_node, FILES))\n\nprint(results)\nprint(\"full suite passes:\", reviewer_node())<\/code><\/pre>\nOutput:<\/strong><\/p>\n
\n![\"Final](\"https:\/\/cdn.analyticsvidhya.com\/wp-content\/uploads\/2026\/07\/image-10-09tepb.webp\")
<\/figure>\n<\/div>\nWhat each layer bought<\/h3>\n
\n - Goal-based:<\/strong> a loop continues its operation until achieving a satisfying end.<\/li>\n
- Execution mechanisms<\/strong>: APIs, web browsers, command line interfaces, code execution language, more<\/li>\n
- Contextual information: <\/strong>guidance, gathered data, dialogue history, approaches to the task<\/li>\n
![\"Riya](\"https:\/\/av-eks-lekhak.s3.amazonaws.com\/media\/lekhak-profile-images\/converted_image_6IQzGzn.webp\")