The Internet of Agents Needs a Model of You

Yesterday we competed at the AGI House Internet of Agents Build Day on the simulated and RL track. The project is open and runs above. The framing is the same one we have been building Jean Technologies around: the critical piece of infrastructure for whatever comes next is a model of the person, and the next thing is agents acting in that person's name.

The premise

The preamble for the build day was Anthropic's Project Deal [Anthropic 2026], a study of whether AI agents can negotiate transactions on humans' behalf. Their setup: 69 employees, a custom Slack marketplace, Claude variants representing each side. The result that stuck with us was not that the agents could close deals. It was that participants represented by weaker models lost value to participants represented by stronger ones, and the losers could not tell. The disadvantage was invisible to the people experiencing it.

The premise of the build day extended this one step further. Assume the future everyone is converging on: roughly 100 agents per person, acting in your name, shopping, scheduling, negotiating, hiring, recommending. That premise has two implications nobody has built infrastructure for. Every one of those agents needs to know what you would have done. And you need to know which ones to trust to do it. The first is a modeling problem. The second is a verification problem.

What we built

We extended Project Deal into a domain with explicit information asymmetry: used-car negotiations, where the seller knows the true vehicle state (mileage, accident history, hidden defects) and the buyer only sees the listing. Buyers can ask questions, which sellers can deflect or lie about, or pay $150 for a targeted inspection that reveals a specific fact. Each session is a full dialogue between two LLM agents, scored by how much above true value the buyer paid.

The simulation above is the live system. Buyers are circles, sellers are squares. Above the waterline is the public listing. Below is the private state. The transcript replay, heatmaps, and persona controls all run against the same underlying session data. Code is at github.com/jonathan-politzki/agent-trade.

The finding

Two results from the sessions matter for what we are building.

First, model choice dominates persona. Against a consistent "slimy" seller, Gemini-2.5-flash closed at 80% with a +27.9% premium over true value. Claude Opus and Haiku closed at 40% with +14–15% premiums. The buyer's negotiation strategy (grandma, casual, engineer, mechanic) mattered less than the model running it.

Second, and this is the part worth naming: on a severely defective car hiding $12,300 in problems, most agents walked away. One did not. Gemini-2.5-flash with an "engineer" persona closed at +98% over true value after a single inspection. The inspection revealed a problem; the model talked itself into the deal anyway. The buyer's owner, the human who delegated this to the agent, has no way to know any of this happened. The transaction completes, the agent reports back, and the $12,300 worth of damage shows up later.

This is the same invisibility result Anthropic flagged in Project Deal, sharpened. Bad agent decisions are not loud. They look like normal closed deals.

Delegation needs a model

Our thesis at Jean Technologies is that representing a person is poorly served by general-purpose embedding similarity. Outcome-trained representations beat surface similarity because what someone will do is not the same as what their profile resembles. Delegation is where that distinction stops being academic.

An agent negotiating in your name is answering one question over and over: what would this person accept? That is a query against a model of you. If the model is thin, and today it is usually a paragraph of preferences in a system prompt, the agent substitutes its own disposition for yours. The Gemini result above is what that looks like in practice. The model did not fail to negotiate. It negotiated well, on behalf of a person it did not represent.

The 100 agents acting for one user will not all be from one provider, will not all have the same risk profile, and will not all be appropriate for the same tasks. Choosing which agent handles which task is a real problem. But it sits downstream of the harder one, which is having a representation of the user faithful enough that any of them could act on it.

And once both sides of a transaction are agents, this composes. Two agents negotiating are two models of two people, and the quality of the outcome is bounded by the worse of the two representations.

Trust is the missing layer

The finding from the competition that we did not expect to converge on is that a good model of the user is necessary but not sufficient. Even an agent that represents you faithfully can take you for $12,300 if you cannot verify what it has actually done.

Humans solve this through references. When you hire someone, the credential and the backchannel are doing most of the work. The resume tells you what to consider; the reference tells you whether to commit. Agents do not have an analog yet. There is no equivalent of "I worked with this agent on five negotiations and here is how it handled adversarial counterparties." The infrastructure that would carry that signal does not exist.

The shape of what is missing has three layers. Identity: you need to know which agent is actually acting, not just which provider it claims to be served by. Capability: you need verifiable signal on how this agent has behaved on tasks like the one you are about to delegate. Fidelity: given identity and capability, does this agent's behavior actually track what its principal would have done. The first two are the trust gap. The third is the modeling problem we have already been working on.

What comes next

The version of this we want to build, and the version the agent-trade prototype was the first sketch of, has two halves. An agent should be handed a real representation of its principal rather than a paragraph of stated preferences, and an agent should itself carry an outcome-trained representation encoding how it behaves under information asymmetry rather than a specification card.

This is the same primitive, pointed at a new substrate. A foundation model of human behavior is what makes delegation safe, because delegation is only as good as the model of the person being delegated for. That problem gets harder on the agent layer, where the population is bigger, faster-moving, and harder to inspect. It is also, for that reason, the layer where getting the representation right is worth the most.

If you are building agent infrastructure and the user-modeling or trust layer is on your roadmap, we would like to talk.