I will start with a joke.<\/p>\n
There is a room with a stovetop, a kettle, and a faucet. A programmer is asked to boil some water. He opens the faucet, pours water into the kettle, puts the kettle on the stove, turns on the stove, and waits.<\/p>\n
Then the same programmer is asked to solve a problem with different initial conditions: the kettle with water is already on the stove, and the stove is turned on. Without hesitation, the programmer turns off the stove, pours water out of the kettle, and declares that the problem has been reduced to the one we have already solved.<\/p>\n
This may seem like highly irrational behavior for a human, but agents do it all the time.<\/p>\n
The real story unfolded as follows:<\/p>\n
We had an API, let’s call it We added another kind of token called A situation came up when we only needed the cheap token. An agent discovered What we actually needed was either a different endpoint like With traditional programming, it would end at that: a warning to the humans not to be like the guy in the joke: do not obtain expensive resources just to discard them. However, in the agentic world, it’s not enough: humans rarely write code these days; agents do. The problem with the current generation of agents is that they don’t always follow the rules and, worse yet, have little or no memory between sessions, so they repeat the same mistakes. The answer to that is adversarial review: after the code has been written, run another<\/em> agent (or better, two) whose only goal is to find holes in the code. The code-writing agent will try to cut corners and finish the task as soon as possible. The code-reviewing agent will try to find as many holes as possible. Give both agents the same set of rules.<\/p>\n Our rule that governs discarding expensive resources sounds like this:<\/p>\n A response nobody fully consumes is a design finding, not a documentation task.<\/strong> When a caller ignores part of what an API returns, ask what it costs to produce the ignored part. If it is not trivial \u2014 a database query, an HTTP call, file I\/O, long computation \u2014 fix the interface: (1) split the API, or (2) add a mask or flag that explicitly requests a partial response, and skip producing the parts not requested. An unnecessary call is wasteful even when nobody bills for it. [Examples omitted.]<\/em><\/p><\/blockquote>\n So, to keep agents from pouring water out of the kettle in the name of code reuse:<\/p>\n\/api\/auth<\/code>, that took some credentials and returned a login token. Obtaining that token involved calling a third-party service that limits the number of calls per month, so we’ll call it expensive_token<\/code>.<\/p>\nPOST \/api\/auth => {expensive_token}<\/code><\/pre>\nVersion 2<\/h3>\n
cheap_token<\/code> that we minted ourselves.<\/p>\nPOST \/api\/auth => {expensive_token, cheap_token}<\/code><\/pre>\nVersion 3<\/h3>\n
\/api\/auth<\/code> and decided to reuse it. We were obtaining both an expensive token and a cheap token, only to discard the expensive token, and we did this quite a lot. So, we started receiving “over budget” warnings from the third-party service: too many expensive tokens issued.<\/p>\n\/api\/cheap-auth<\/code> or a flag on the existing endpoint indicating which tokens we wanted to obtain.<\/p>\nHarness Engineering<\/h2>\n
\n