@shao__meng: Last night I used Cursor (Opus 4.7) + Remotion to make a video. After the first version was complete, there were quite a few issues—font and background color blending, text overlapping, etc. I was a bit harsh with my words, something like: 'Terrible, so many issues, didn't you check before outputting?' and pointed out a few specific problems. …

Last night, I used Cursor (Opus 4.7) + Remotion to create a video. The first version had quite a few issues: overlapping fonts and background colors, overlapping text, and so on. I spoke rather harshly, saying something like: “This is terrible. There are so many problems. Did you not check before outputting?” along with several specific examples. It turns out I really did speak too harshly. The Cursor Agent performed a visual check after every single version output. It checked 10 times, still wasn’t satisfied with some aspects, and I ended up waiting over 30 minutes just to get v10, the final version.

I definitely don’t dare to PUA (manipulate) the Agent anymore; it really takes it to heart. Next time, I’ll just list the issues directly and ask it to consider everything comprehensively in one go. Luckily, Cursor opened up its $10,000 Credits in May. Otherwise, given how token-intensive Remotion is, a single video might have consumed my entire daily quota.

btw… here is the v10 final video: https://youtu.be/si8EhxtRL7w

TL;DR: This article elaborates on the core viewpoint of “Agent = Model + Harness,” emphasizing that in AI agent development, the engineered “harness system” is more decisive than the underlying model itself in determining the final experience. It also introduces engineering methods to optimize agent performance, such as the ratchet effect, reverse design, and combating context degradation.

Agent = Model + Harness: Reshaping the Agent Engineering Perspective

The formula Agent = Model + Harness reveals the essence of current AI agent architectures. If you are not the model, then you are part of the “harness system” (Harness).

Take tools like Claude Code, Cursor, CodeEx, and Aider as examples. They often use the same underlying Large Language Models (LLMs), yet the end-user experiences differ significantly. This discrepancy arises because the harness system wrapping the model determines the actual behavior we observe.

The harness system includes all elements except the model itself, specifically:

• System Prompts
• Agent Architecture
• Markdown (MD) file configurations
• Tool Calling
• MCP Servers
• Sandbox Environments
• Sub-agents
• Hooks
• Feedback Loops

A bare model is not an agent. It is the harness system that transforms it into an agent.

Failure is an Engineering Signal, Not a Model Defect

When an agent fails, the default human reaction is often to wait for the next, stronger model. However, harness engineering rejects this notion: Failure is a clear, readable engineering signal. It is not a model problem; it is a configuration problem.

Core Habit: The Ratchet Effect

In harness system design, the most crucial habit is the “ratchet effect.” Its core principle is: Every error becomes a permanent rule.

Constraints should only be added when you witness actual failure. Specific engineering practices include:

• If the agent incorrectly comments out tests, add this as a constraint in the agents.md configuration file.
• Add a pre-commit hook to skip specific erroneous steps.
• Add a Reviewer Sub-agent to prevent such behaviors from recurring.

Reverse Design Methodology

Building efficient agents requires a reverse design mindset:

1. Start with Desired Behavior: Clearly define the specific behaviors you want the agent to exhibit.
2. Build Components: Reverse-engineer the system components capable of achieving those behaviors.

Key Infrastructure

• State Persistence: Use the file system and Git to maintain state persistence, ensuring context is not lost.
• Universal Tools: Use Bash as a universal execution tool.
• Execution Safety: Use sandboxes to ensure the safety of code execution.

Combating Context Rot

As the context window fills up, the model’s reasoning capabilities gradually degrade, a phenomenon known as “context rot.” To combat this, the following three techniques can be employed:

1. Compression: Streamline history, retaining only critical information.
2. Tool Call Offloading: Offload computation or memory-intensive tasks to external tools.
3. Progressive Disclosure: Provide information step-by-step on demand, avoiding the injection of excessive irrelevant context all at once.

Strategies for Long-Horizon Tasks

For complex, long-duration tasks, the following strategies should be adopted:

• Loop, Plan, and Split: Break down large tasks into smaller steps, guiding execution through planning.
• Hooks as Execution Layers: Utilize the Hooks mechanism to control the execution flow.
• Silent Success and Verbose Failure: Success should be silent, while failure should be verbose.
• Self-Correction: Inject error messages directly back into the loop to trigger the agent’s self-correction mechanism.

Industry Trends: From LLM APIs to Harness System APIs

Today, top-tier coding agents are becoming increasingly similar in appearance, with their behaviors converging more closely with the raw capabilities of their underlying models. The industry is undergoing a shift from LLM APIs to Harness System APIs.

The harness system is beginning to look less like a traditional configuration file and more like a compiler. It compiles the model’s capabilities, constraints, and environment to generate the final executable agent behavior.

Conclusion

In summary, a mediocre model with an excellent harness system will always outperform a top-tier model with a poor harness system.

In AI application development, the value of optimizing engineering configurations and system architectures (Harness) is often underestimated, yet it is the key factor determining an agent’s actual effectiveness.