The Agent Moved In. Code Is Now the Address.
There’s a paper that dropped this month from UIUC, Meta, and Stanford. Forty-something authors. A hundred-plus pages. Title: Code as Agent Harness.
Here is the complete paper.
You don’t need to read all of it.
You need to understand the one idea it’s built on, because it quietly reframes everything happening in agentic AI right now, and it does it in a way that most teams are nowhere near ready for.
Here it is: code has stopped being what AI agents produce. It’s become the substrate they run on.
That’s it. That’s the shift.
And the weird part? Once you see it, you can’t unsee it.
From Output to Operating Surface
For the past two years, the dominant mental model of AI + code has been something like:
Human asks AI a question. AI writes some code. Code runs. Done.
Code as output. AI as very fast typist with a CS degree.
That model is already outdated.
What’s actually happening in modern agentic systems is closer to this: the code is the agent’s world. It’s how the agent reasons, remembers, takes actions, verifies its own work, and coordinates with other agents. The agent doesn’t just write code. It lives inside code.
The paper calls these layers the harness interface, harness mechanisms, and harness scaling. But what they’re really describing is a new kind of infrastructure, one where code is the connective tissue of an entire cognitive system.
The Four Words That Will Show Up in Your Next Procurement Call
Here’s where it gets interesting from a non-academic perspective.
The paper describes four properties that a well-built harness needs to have:
Executable. Inspectable. Stateful. Governed.
Now. Read those four words again. Slowly.
Those aren’t research criteria. Those are audit criteria.
Any CISO or procurement officer who’s ever been in a regulated industry will recognize that vocabulary instantly. Not from AI papers, but from the checklist they use before signing anything.
Can this system be run reliably? (Executable)
Can we see what it did and why? (Inspectable)
Does it remember context correctly across sessions? (Stateful)
Can we control what it’s allowed to do? (Governed)
The paper wasn’t written as a procurement guide. But it reads like one, where they lay out the open challenges. And those open challenges are, not coincidentally, the exact questions that enterprise deals get blocked on.
“Evaluation beyond final task success.” Translation: “We can’t just check if the AI got the right answer. We need to know how it got there.”
“Human oversight for safety-critical actions.” Translation: “Before this agent touches production, we need a kill switch with a paper trail.”
“Consistent shared state across multiple agents.” Translation: “When Agent A and Agent B both think they own the same task, who’s right and how do we know?”
The Split That’s Already Happening
Enterprises building AI systems right now are quietly dividing into two camps, and most of them haven’t realized they’ve already chosen a side.
Camp One: The agent is the product.
These teams move fast. They ship demos that impress. They iterate on prompts. They optimize for “wow, it works.” Their architecture looks like a model call wrapped in some business logic and a Slack notification.
For the last 24 months, these teams have been winning on velocity.
Camp Two: The harness is the product.
These teams move slower initially. They spend time on observability, state management, rollback mechanisms, and evaluation infrastructure. Their demos are less flashy. Their architecture diagrams have more boxes.
Here’s the prediction I’ll make: Camp Two is about to start winning on contracts.
Because the questions in a regulated enterprise sales cycle, the ones that stall deals, block procurement, and require three extra security review meetings, map almost exactly to harness properties. Not model benchmark scores.
A model getting 90% on HumanEval does not tell your legal team whether the agent can be held accountable for a wrong output. A well-built harness does.
What “Open Problems” Actually Means
Academic papers have a tradition of ending with an “open problems” section that reads like a polite to-do list for future grad students.
Section 5.2 of this paper has seven items.
Naah. Those aren’t grad student projects. Those are unbuilt companies.
Let me translate a few:
“Regression-free harness improvement” means: how do you upgrade your agentic system without breaking the behaviors that were already working? Sounds boring until you realize that every enterprise AI team rebuilding a workflow from scratch every time they update the underlying model is currently doing this manually, at significant cost, with significant anxiety.
“Verification under incomplete feedback” means: the agent takes an action, the outcome isn’t immediately clear, what does the system do? This is the difference between an AI that handles ambiguity gracefully and one that confidently proceeds in the wrong direction for forty-five minutes before anyone notices.
“Extensions to multimodal environments” means: the harness needs to handle not just code execution, but GUI interactions, images, documents, and the glorious chaos of real enterprise systems that don’t have APIs.
Each of these is a product opportunity. Also a sales objection. Also a headline waiting to happen when something goes wrong.
The Acquisition vs IPO vs Nowhere Prediction
Here’s a framework I’ve been thinking about for how this cycle plays out:
The companies that get acquired will be the ones that built elegant harnesses. Great observability, clean governance hooks, reliable state management. Acqui-hires with infrastructure value.
The companies that go public will be the ones that built the models. Massive compute, massive moats, massive narratives.
The companies that go nowhere will be the ones that insisted the model would eventually subsume the harness. That if they just waited for the next model release, all those messy infrastructure problems would solve themselves.
They’re not entirely wrong. Models are getting better at managing state, self-correcting, and handling long-horizon tasks. But “eventually” is doing a lot of work in that sentence. And in enterprise software, the gap between “eventually” and “now” is where entire companies live and die.
So What Do You Actually Do With This
If you’re building something in the agent infrastructure space, here’s the practical read:
The vocabulary in this paper is about to become the vocabulary of enterprise RFPs. “Executable, inspectable, stateful, governed” will show up in procurement checklists written by people who have never read an arXiv paper in their life. They’ll arrive at those words independently, because those words describe what their auditors need.
If your system already satisfies those four properties, you have a story to tell.
If it doesn’t, you know what to build next.
If you’re not building but funding, buying, or selling agent infrastructure: Section 5.2 of this paper is the closest thing to a market map you’ll find for the next eighteen months. It’s not written as one. But that’s what it is.
The Strangest Part
Forty researchers from three of the world’s top institutions spent considerable time agreeing on a vocabulary for how code functions in agentic systems.
That in itself is a signal. Surveys like this don’t happen when a field is still chaotic. They happen when the field is settling, when the concepts are crystallizing, when someone is about to build a standard.
And somewhere in a procurement department, an auditor is writing a checklist that will, without knowing it, match this paper almost exactly.
That’s when research stops being research. And infrastructure stops being infrastructure.
That’s when it becomes the thing you absolutely cannot ship without.
Support my work : buymeacoffee.com/HardikGoel
The paper: “Code as Agent Harness” (arXiv:2605.18747) — UIUC, Meta, Stanford, 40+ authors. Worth a skim of the abstract and Section 5.2 at minimum.