I wrote an article explaining what an agent and a harness are with some detail. There is so much untapped potential in harnesses still, I think because we do not take the time to parse exactly what they are.

https://aweb.ai/blog/what-an-ai-agent-is-a-primer/

Depending on how we define harness, it's at its core a loop around llm calls with the tool field populated and a function per to use them after a round trip, easily fits into a single file in a crude setup. I think everyone should try writing a simple harness just for the learning experience, it gets thorny rather quickly.

Another aspect to this is model training, since bots are now being trained with a harness, and that has the tools it gets most burned in to weights. In my own harness, I tried Read,Edit,Write tools which always put the latest text of a file upfront, only one copy, to reduce context window growth as the bot tended to reread a file before/after edits. While this greatly slowed window growth, cache hits dropped to ~50%. If you give the bot a Grep and Read with Offset/Limit, this aligns with training and reduces window growth, even with the read-before-write pattern. You can see the pattern of grep-read when it does the default "use bashisms for everything instead of the dedicated tools"

I'm now exploring ways to remove the need for a shell tool completely, for various reasons, but notably limiting potential for loss of control. Early experiments hint this will not work well due to the heavy shell usage in training, but I'm not throwing in the towel just yet!

Wait until you realize that deep down everything on a computer is text. We juist build "harnesses" to manipulate in-memory "text" in different ways.

One level deeper is all numbers though.

And eventually it's all 0 and 1s!

I agree with you, accuracy of answers and the ability to complete task is the most important thing. But once a system can achieve a goal, throughput and cost come into consideration. In this regard, I think cache rates help make things both faster and cheaper.

One of the main things I've noticed is that several of the techniques are well intentioned for other reasons. For example, when we debug low cache rates with users probably culprit #1 is usually some memory system. Many of those memory systems are trading a stable prefix for the ability to augment the current turns request with some new memory data. For some -- this may be the right trade-off, but the impact is slower responses times due to the extra prefill compute.

So when a memory system promises better LLM performance the other trade-offs aren't necessarily well understood (at the expense of caching).

Features like OMP trying to clean up history to shrink context I think are also well intentioned. But I found these trade-offs interesting hence wanting to share.

It's easy to break the cache and there's a number of very valid usecases (mostly context management such as compaction or tool shaking).

Not to mention that it can be very strategic to break context. E.g, after chasing a bug for a while it does make sense to summarise all the approaches that did not work so that you have more context available for newer approaches.

Getting 99% cache hit rates while providing a good user experience is the hard part!

> I wrote the post.

It's strange that people who have LLMs write entire articles for them often claim this. It might be true that you prompted it with your ideas, but the result is still in its own style, and style (and it variety) is why we prefer to read human text.

Hobbyist harness builder here. Thank you for the article.

What would be helpful would be a cheap API call that would give me the energy cost estimates:

> Given some prefix-cache uuid, what is the cost (in mW of GPU energy) of adding X tokens that will branch off from what's been cached at offset Y tokens.

Suppose at some turn n, I read a file and pull it into the context. Now at turn n+m, I discover that the file has mutated on disk. The most energy efficient option might be any of these:

1. Replace the content of the file in the cache

2. Append the new file to the end of the cache

3. Add a thing to the context saying the file has been updated.

4. Compact memory then do option #3

As a harness builder, it's pretty hard for me to pick the most energy efficient strategy - I assume every model has a different cost for prefill vs decode and I also expect that a provider (an inference cloud) might have slightly different implementations that would impact how expensive a prefix-cache miss is.

Ofcourse, I also need to target aggregators like openRouter because as a solo hobbyist harness builder, it's really hard for me to track every cloud's unique API. Then there's the fact that I'm optimizing for lowest billed cost, not lowest energy consumption.

I'm waiting for the industry to standardize on a good way to express these in an API so that I can start doing these tradeoffs at runtime in my harness.

[flagged]