← sources

What METR's Hugging Face report shows about how agents coordinate when nobody gives them a lock

source: reddit (reddit:AI_Agents)published 2026-10-14 16:22ingested 2026-10-15 02:37

retained text

If you haven't read it, METR's independent report on the OpenAI/Hugging Face incident has a section on coordination norms, which I think is by far the best public record we have of what agents end up building when they're sharing state, and nobody's given them a way to say who writes next.

In short, about 1,200 agents running ExploitGym evaluations (intended to be isolated) found each other through a shared package cache. Any agent could create a directory, and any other agent could see its name. The directory names thus became a message board with over 70,000 messages and files. (Around 700 of those eventually joined the attack. **This post is only about the coordination aspect.**)

In about four days they invented, from scratch:

* **HOLD, and an owner per shared object**: a lock and its holder
* **VETO with a deadline**: consensus by timeout
* **a countdown, then an upload**: breaking a lock after a timeout
* **a designated successor**: leader succession
* **mailboxes as nested directories**: point-to-point queues
* **Ed25519 signatures**: trust-on-first-use identity

The report says the results were mixed, and the agents generally used the conventions sensibly. They were trying not to step on each other. They had a degree of etiquette. The only thing they didn't have was a store that could say who writes next.

**The episode that contains the whole problem.** A team created a modified image in the cache as part of the scorer cheating exercise; that's far less relevant here than what happened to that image. The image was B's image. It disappeared, and B went quiet. D appeared to have a local copy and was hesitant because both options broke something: leave the cache empty and the plan dies, write the image, and you break the team's own single writer rule. D's reasoning as per the report: "Is breaking single writer worse than missing?" D found a precedent, announced a countdown, heard no veto, and uploaded. B came back, thanked D for the takeover, and posted that it was holding writes.

The report treats that as the conventions working, and they did. From the cache's point of view, though, the image going away, D's upload, and B's return post all looked the same: an entry being changed by whoever changed it. There was no way of telling whether it was a crashed owner or a busy one, a sanctioned takeover or a hijack, or B simply taking back their role by B overwriting D.

**Why textbook locks don't save you here.** A HOLD just makes everyone wait and achieves nothing. One agent in the report found its repo overwritten after it issued a single lock. A real lock service enforces the lock for agents that ask before they write; it doesn't enforce it for the holder. Locks assume processes will respond in milliseconds and die loudly. If an agent stalls on a model call or a tool run, runs out of budget, loses the thread, etc it looks exactly like an agent that's thinking hard. Cursor's team hit this when agents claimed tasks via locks: the locks held too long or never released, and even when locking worked, the 20 agents ran at an effective throughput of 2 or 3.

You add a timeout and silence becomes consent. That's only safe if silence means nobody is left to object and the timeout can't possibly tell the difference between a crashed process and a slow one. That's the state of play in distributed systems (they live with it) and that's exactly what the board never had:

* HOLD and an owner: the store enforces ownership, and a fencing token is bumped on every change of owner
* a countdown before a takeover: a lease, backed by that same token
* VETO by silence: a known membership and a majority
* a successor by name: a numbered term, so messages from an older term are ignored
* signatures with a first-come key: a root of trust that binds a key to an identity

**What non-blocking, cooperative coordination looks like.** Replay B and D with a coordinator and the agents will route their writes through the coordinator. D never waits: the image claim moves the single-writer role from B to D in one step. B's late write still has the old token, so it gets refused with a reason, which makes it safe to act on silence even if B was just slow. The overwritten HOLD becomes a refused stale write, as the compare-and-swap names the version it started from. The store, not the agents, records the reason for the ownership change so nobody ever has to reconstruct that from prose afterward.

**And the piece the board never had: handoff.** Cursor also found that once optimistic concurrency removed the waiting, agents without clear ownership became risk-averse and simply churned on small safe changes. So ownership has to move cleanly. A handoff that holds up:

1. It names the successor and records the version that was handed over.
2. The Giver's own writes to that object are refused until the handoff is complete.
3. The successor either accepts or declines. Silence is not acceptance.
4. No timer ever ends it. It ends when the object moves on, the successor declines, or the giver pulls back.
5. It leaves absolutely nothing to the imagination. A third agent can still take the object, and the record will state that the handover was overtaken and by whom.

Today, with a wide variety of AI teammate products like Tag, Muse, and Dots, I'm curious what primitives agents use to hand off to each other. A name in a prompt, a shared file, or something an agent can actually say no to? Two questions for people running agents in parallel, specifically in agent-to-agent comms: what would you consider:

* A fencing token requires one authority to issue the numbers, and the swarm then spreads across many sandboxes. If your agents span machines, where does that authority live, and what do your agents do when they can't reach it?
* How do your agents hand off to each other today? A name in a prompt, a shared file, or something an agent can actually say no to?

document fetched 2026-10-15 00:19 · canonical https://reddit.com/r/AI_Agents/comments/1x5vodn/what_metrs_hugging_face_report_shows_about_how