The rapid development of products such as Agent, Codex, and Claude Code has led to the emergence of a number of new terms in the field of AI engineering: Prompt Engineering Context Engineering Loop Engineering Harness Engineering There are more and more new terms, and the boundaries are becoming increasingly blurred.
If you put these concepts into the technological evolution of the past three years and observe them, you will find that they actually describe the focus of the same thing at different stages.
The entire process can be understood as the gradual development of AI systems from single-turn conversation tools to software systems that can continuously perform tasks.
There will be more and more new concepts of XXX Engineering around Agent, because the application side should essentially focus on innovation and practice at the engineering level, similar to the various models, terminology, middleware, etc.
that have been accumulated in the traditional software ecosystem in the past 30 years.
The Agent application layer is also going through such a process, and everyone should slowly get used to it.
Phase 1: Prompt Engineering The most popular concept in 2023 is Prompt Engineering.
The mainstream working model at that time was very simple: Prompt ↓ LLM ↓ Response.
The main issues that engineers focused on were: How to write Prompt Few-shot How to design Role Prompt How to organize Chain of Thought How to guide the output format How to constrain the output format The core goal of that stage is: Improve the quality of a single answer.
For example: Please play the role of a senior architect.
Please think in steps.
Please output a Markdown table.
These techniques produced very obvious effects in the early stages of GPT-3.5 and GPT-4.
Prompt Engineering has promoted the birth of a large number of AI applications and also trained the first batch of AI application developers.
However, with the rapid improvement of model capabilities, everyone gradually discovered that: Prompt solves the single-round interaction problem.
Many real business problems require continuous execution, multiple rounds of decision-making, and long-term state management.
So the second phase begins.
Phase 2: Context Engineering Starting in 2024, more and more teams are turning their attention to Context Engineering.
Because everyone has discovered that: Model capabilities are getting stronger and stronger.
Context quality starts to become a major bottleneck.
At this time, the system structure becomes: Context ↓ Prompt ↓ LLM ↓ Response The focus changes: What content is retrieved How much content is retrieved How to sort How to compress How to organize the context The rise of RAG is an important symbol of this stage.
For example: Enterprise knowledge base Q&A: User question ↓ Vector retrieval ↓ Knowledge fragment ↓ Model answer At this time, the engineer is concerned about: What the model should know.
Prompt is still important.
But Context has become a major factor affecting the results.
OpenAI, Anthropic, and Google all continue to expand the context window at this stage.
From 8K to 32K to 128K to million-level context.
The entire industry is beginning to realize that high-quality context is a capability in itself.
Phase Three: Loop Engineering After 2025, the development of Coding Agent and Autonomous Agent has brought new changes.
Everyone found that: Many tasks have exceeded the scope of a single round of answers.
For example: fix a bug, complete a feature, analyze a system, write a research report.
These tasks often last dozens of minutes or even hours.
The system structure begins to evolve into: Think ↓ Act ↓ Observe ↓ Verify ↓ Iterate This is the Agent Loop.
After having Loop, how to ensure the quality and reliability of Loop?
Loop Engineering and Agent Loop need to be distinguished.
Agent Loop is an execution loop like Think / Act / Observe / Verify / Iterate; Loop Engineering is the design, constraint, verification, and optimization of loops.
Agent Loop is the operating form, and Loop Engineering is the engineering method built around this operating form.
This brings us to Loop Engineering.
Although this topic is very popular recently, it has actually been practiced in the industry for a long time, but it has not been proposed as an independent concept.
Issues that Loop Engineering focuses on include: How to plan tasks How to disassemble tasks How to execute tasks How to verify results How to proceed to the next iteration For example, Codex: View code ↓ Modify code ↓ Run test ↓ Analyze results ↓ Continue to modify Claude Code: Search files ↓ Read code ↓ Modify code ↓ Execute command ↓ Verify results OpenHands: Plan ↓ Act ↓ Observe ↓ Reflect These systems all revolve around Loops.
Loop Engineering's core goals are: Improve mission completion rates.
Prompt Engineering cares about answer quality.
Loop Engineering focuses on the quality of task completion.
This is an important dividing line in the Agent era.
In the enterprise agent system, Loop Engineering can be understood under Harness Engineering.
Loop is responsible for how individual tasks continue to advance, and Harness is responsible for runtime, tooling, permissions, evaluation, memory, observability, and security boundaries.
This division is not a unified standard, but it is more consistent with project implementation.
Phase Four: Harness Engineering Since the past year, more and more teams have focused their discussions on Harness Engineering.
The reason is simple.
When Agents start to work continuously, new problems arise: How to manage multiple Agents How to manage tools How to manage memory How to manage reviews How to manage costs How to manage safety boundaries How to manage long-term running states These issues have gone beyond the scope of a single Loop.
So the concept of Harness began to emerge.
If you look at it from a software engineering perspective: Prompt Engineering focuses on function calls.
Loop Engineering focuses on business processes.
Harness Engineering focuses on the entire operating platform.
A typical Harness includes: Goal ↓ Orchestration ↓ Agent ↓ Tools ↓ Loop ↓ Evaluation ↓ Memory ↓ Observability ↓ Guardrails At this time, Loop has become an integral part of Harness.
Therefore: Harness Engineering contains Loop Engineering.
The two are not parallel.
A more accurate understanding is: Harness Engineering includes ├─ Loop Engineering ├─ Evaluation ├─ Memory ├─ Observability ├─ Guardrails └─ Orchestration Loop is the engine.
Harness is the entire vehicle.
Why does this evolution occur?
What corresponds to this is the continuous expansion of the capabilities of AI systems.
Phase 1: The model answers the question.
Phase 2: The model uses knowledge to answer questions.
Phase 3: The model performs tasks.
The fourth stage: The model participates in the operation of the software system.
Therefore, the focus of the entire industry continues to shift to systems engineering.
More and more teams are beginning to pay attention to: Trace Evaluation Agent Runtime Memory Tool Use Observability These traditional software engineering concepts have returned to the AI world.
Recommended Reading Loop Engineering Addy Osmani https://addyosmani.com/blog/loop-engineering/ Firecrawl https://www.firecrawl.dev/blog/loop-engineering Oracle Agent Loop https://blogs.oracle.com/developers/what-is-the-ai-agent-loop-the-core-architecture-behind-autonomous-ai-systems Harness Engineering OpenAI Harness Engineering https://openai.com/index/harness-engineering/ Martin Fowler https://martinfowler.com/articles/harness-engineering.html Anthropic Long-running Agents https:/ /www.anthropic.com/engineering/effective-harnesses-for-long-running-agents Recommended papers ReAct https://arxiv.org/abs/2210.03629 Toolformer https://arxiv.org/abs/2302.04761 Reflexion https://arxiv.org/abs/2303.11366 Agentic Harness Engineering https://arxiv.org/abs/2604.25850 From Agent Loops to Structured Graphs https://arxiv.org/abs/2604.11378 Recommended open source projects Codex CLI https://github.com/openai/codex OpenHands https://github.com/All-Hands-AI/OpenHands OpenAI Agents SDK htt ps://github.com/openai/openai-agents-python PydanticAI https://github.com/pydantic/pydantic-ai LangGraph https://github.com/langchain-ai/langgraph Recommended videos Andrej Karpathy: Software Is Changing https://www.youtube.com/watch?v=LCEmiRjPEtQ Anthropic Developer Day https://www.youtube.com/@AnthropicAI OpenAI DevDay https://www.youtube.com/@OpenAI LangChain Agent Engineering Series https://www.youtube.com/@LangChain In the past few years, the field of AI engineering has experienced a very clear path.
Development path: Prompt Engineering ↓ Context Engineering ↓ Loop Engineering ↓ Harness Engineering Prompt determines how the model starts working.
Context determines what information the model can obtain.
Loop determines how the task continues to progress.
Harness determines how stable the entire system operates.
Today's Agents have gradually evolved from chatbots to long-running software systems.
The most valuable capabilities in the next few years will increasingly focus on system design, evaluation systems, memory management, observability, and runtime engineering.
Model capabilities remain important.
Engineering systems are becoming a key factor in determining the upper limit.
