Agent on Yanmu

What Are Agent and Harness? — Video Notes

Mon, 25 May 2026 02:00:00 +0800

One-Sentence Summary

An Agent solves how AI gets work done; a Harness solves how AI does work reliably. Together, they form the foundation of products like Claude Code, Codex, Open Cloud, and Qwen.

1. From ChatGPT to AI Agent

The Original Problem

Asking ChatGPT to create an animation with HTML + SVG (e.g., an Apple logo drawn with lines) often produces poor results — even in 2026, AI struggles with even a minimalist logo.

Manual Improvement

Search for Apple SVG assets on sites like iconfont
Feed the SVG code to AI and ask it to recreate it
Results improve significantly, but manually finding assets every time is tedious

Automated Improvement — Wrapper Sites (Earliest Agent Prototype)

Build a website that wraps ChatGPT via API calls, adding backend functions:

User submits request → The site tells AI: “Here’s the user’s prompt. I also have a logo search function you can call when needed.”
AI analyzes → Determines it needs an Apple logo, responds: “Call the asset search tool with parameter: Apple logo”
Site executes → Backend runs the search function and finds SVG assets
Final generation → The site sends assets + user prompt to AI to complete the animation

2. Two Core Working Modes of Agent

1. ReAct (Reasoning + Acting) — Step by Step

Three-step loop:

Think: AI analyzes the request, determines what’s needed and which tool to call
Act: AI tells the backend to call a tool (e.g., search for assets)
Observe: Backend returns results; AI sees them and continues

The loop repeats: Think → Act → Observe, until the task is complete.

This is the most fundamental working pattern of almost all AI Agents, including Claude Code, Codex, and Open Cloud.

2. Plan & Execute — Plan First, Then Execute

Plan first: Generate a work list / step sequence upon receiving the task
Execute: Follow the checklist step by step

Mode	Analogy	Characteristic
ReAct	Improvise as you go	Flexible, adjust on the fly
Plan & Execute	Research before traveling	Structured, suited for complex tasks

Real agents combine both. For example, Qwen’s “Task Assistant” mode: first analyzes requirements and creates steps (Plan), then proactively searches, writes code, and adjusts (Act).

3. Advanced Agent Capabilities

Tool Calling / Function Calling

The Agent determines which tools to call based on the user prompt; the backend executes them and returns results.

Context Management and Compression

Large models have no memory — each conversation starts fresh
The Agent must send the entire conversation history to the AI each time, which grows longer over time
Context window = AI’s workspace, limited in size
Context compression: When the conversation exceeds the window, earlier content is summarized into a condensed version
- Trade-off: compression loses information, potentially causing the AI to forget previous instructions

Multi-Agent Collaboration

One AI acts as the project manager (understanding requirements, breaking down tasks, assigning work), while other AIs execute subtasks.

Each sub-AI has its own independent context window
The project manager only sees final results, not intermediate steps
Improves efficiency while mitigating context explosion

4. Harness — The Safety Net for Reliable AI

When Agents run in production, they encounter various issues that need a Harness to solve.

Engineering Checkpoints in a Harness

Checkpoint	Problem	Solution
Format Sanitization	AI adds “okay”, markdown code blocks, or extra newlines when returning JSON	Clean: remove fluff, wrapping symbols, extra newlines; send errors back for regeneration if still failing
Parameter Validation	Tool call parameters are invalid (e.g., city field contains a non-city name)	Validate format/range before calling; reject and request refill if invalid
Input Filtering	Prompt injection attacks (“ignore all previous instructions”) / malicious SVG uploads	Scan user input for suspicious instructions and asset safety before processing
Output Filtering	AI-generated content may contain malicious code	Scan output content for threats
Hard-Coded Validation	AI repeatedly makes the same error (e.g., always using pure white backgrounds)	Enforce with code: auto-detect SVG background color and replace white with dark

Core Principle of Harness Engineering

If you can enforce it with code, never rely on prompting alone.

5. Complete Architecture Summary

One Sentence to Elevate

Agent is the horse; Harness is the tack. A horse without tack runs into problems; tack without a horse does nothing. Together, they transform AI from a chat-only chatbot into a worker that gets things done in the real world.

The Evolution of AI Programming

Fri, 20 Mar 2026 02:00:15 +0800

🤖 The Evolution of AI Programming: From Prompts and Context Engineering to Harness

As models with comparable capabilities become increasingly common, the gap in user experience between different products is actually widening. Some products write code that can be deployed directly, while others produce code that is hard to maintain—why? Because the models are the same; the difference lies in how they are used, and how to use them stably. In the AI industry, this is known as Harness Engineering.

🧠 Harness Engineering: Deconstructing the Agent into Three Layers

We divide programming Agents into three levels:

Scaffolding Responsible for all preparatory work before the AI executes a task, including the tools provisioned by the system.
Harness (Runtime Orchestration, The Core) The central dispatching hub of the entire agent. Responsible for managing the AI’s core reasoning loop, coordinating tool calls, context management, runtime security control, and persistent storage of session data.
Context Engineering Responsible for managing the resource allocation of tokens—the smallest unit of computation for large language models processing text. Determines which information should be retained and which should be discarded during the AI’s operation.

A stable and capable AI coding agent = One or more LLMs called + A robust Harness system.

⏳ Harness is Crucial, Why is it Only Getting Popular Now?

① Phase 1: Prompt Engineering

Core Focus: How to write a good instruction.

Role Setting: Defining clear identities and responsibility boundaries for the AI.
Providing Examples: Using Few-shot prompting to make the AI generate content according to a specific format and style.
Chain-of-Thought: Asking the AI in the instruction to break down the problem step-by-step and deduce logically, reducing logical leaps and errors.

② Phase 2: Context Engineering

A single prompt is no longer enough—we need to dynamically construct the entire context environment for the model. Ensuring that every time the model makes a decision, it can accurately see all the information it needs: task files, conversation history, tool rules, knowledge base entries…

Core Concept: Show the model what it needs to see, and block what it shouldn’t.

③ Phase 3: Harness Engineering

Whenever you find the Agent making a mistake, you spend time engineering a solution so it won’t make the same mistake again.

The model’s capabilities are sufficient, but it just won’t listen. What do we do? The answer is—Harness Engineering.

Real-world Cases:

Experiment	Condition	Result
LangChain	Same model, optimized Harness only	Terminal Bench 2.0: 52.8 → 66.5
Nate B Jones	Same model, same prompt, changed runtime environment only	Coding benchmark win rate: 42% → 78%
OpenAI	Started from an empty git repo, 5 months, entirely AI Agent driven	Produced ~1 million lines of code, 1500 PRs, zero human intervention

The Agent isn’t hard; the Harness is.

💥 Why Do AI Tasks Fail So Frequently?

1. Trying to do it all at once Trying to finish all features in a single window results in the context window rapidly depleting, causing a steep drop in quality towards the latter half.

2. Declaring victory too early In the later stages of complex project development, once the AI agent completes the core functions and has visible output, it directly determines the task is complete and actively terminates—even if a large number of features are unimplemented and core requirements are unmet, it will still stop.

3. Marking features as complete too early As soon as the AI agent finishes writing a feature, it marks it as complete. It will not actively perform end-to-end full functional tests, nor will it verify whether this feature is actually usable in a real environment. It looks like it runs, but in reality, it’s full of hidden bugs.

4. Mechanically copying code patterns AI will mechanically follow existing code patterns (architectural style, coding conventions), even if the pattern is wrong, and continuously amplify it throughout the project. An unconstrained AI agent will accumulate a massive amount of technical debt in a project at extreme speeds.

🛡️ The Four Guardrails of Harness

🔹 1. Context Engineering

The longer and more redundant the AGENTS.MD file is, the lower the Agent’s task success rate, while the inference cost becomes higher. The AGENTS.MD file should be strictly kept under 60 lines.

Context is a scarce resource; too much guidance will crowd out the truly important task code.

🔹 2. Architectural Constraints (The Core)

Implement a strict layered architecture—not by telling the agent “please follow the architecture” via a prompt, but by mechanically enforcing it using deterministic Linters and structured tests.

Embed repair guidelines directly into the Linter error messages, telling the agent how it should be fixed. Constraints are more effective than instructions.

🔹 3. Feedback Loop

In Harness, code review becomes an Agent-to-Agent process. Forming a standardized closed loop: Plan & Discover → Build → Verify → Fix, cycling continuously to consistently purify code quality.

🔹 4. Entropy Management

Over time, AI-generated code accumulates numerous issues: outdated documentation, architectural drift, styling deviations, accumulation of dead code… Letting an Agent maintain documentation for the Agent continuously fights against entropy increase and prevents project rot.

🧭 Conclusion

The evolution of AI programming is essentially a paradigm shift from “writing good prompts” to “building good systems”.

Prompt Engineering solves “how to say it”.
Context Engineering solves “what information to give”.
Harness Engineering solves “how to manage/control it”.

These three paths are not mutually exclusive but rather additive and progressive—each layer builds on the foundation of the previous one. A truly capable AI programming product that stably outputs high-quality code must have invested serious effort across all three of these levels.