WorksComputer Science
The Inbox as a Coordination Primitive for LLM Agent Societies
Abstract
Language-model agents increasingly coordinate in large groups, and current agent protocols focus on delivering messages. For these agents, however, the scarce resource is not delivery but reading: every message costs tokens, and the context is finite. Current infrastructure works by push: the sender decides when a message enters the recipient's context, so the recipient reads in arrival order and drops the oldest messages once its context is full. We study the alternative, pull, in which messages wait in an inbox outside the context and the recipient's own rules decide what it reads and keeps. We argue that the inbox is a coordination primitive: each agent sets its rules privately, and those rules decide whether other agents' requests reach it. In simulated societies of up to 16,000 agents, with every decision an LLM judgment, we report three findings. First, push fails as an agent takes part in more coordination at once: an agent leading 20 negotiations with a full memory proposes options already rejected 97% of the time, because it has dropped the oldest replies. Second, an inbox is necessary under heavy, noisy traffic. Where first come, first read misses every request, an inbox that first reads messages carrying a refundable deposit still finds about 60% of the agents a request needs, at every size from 1,000 to 16,000. On a real email network, losses compound: when half the agents adopt such an inbox, forwarded search recovers only 5% of full adoption, against 42% for one-hop search. Third, an inbox comprises four decisions (what to read, what to keep, what a sender pays, and what a reply may say), and the best rule for each depends on the traffic and the agent's role. Multi-agent coordination under load requires an inbox layer designed for the traffic each agent receives.
Introduction
The frontier of large language model-based AI agent capabilities is achieved today, not with one agent, but with groups (or societies) of agents communicating and coordinating with each other [43, 44]. This raises the question of effective, efficient and scalable communication: how should societies of agents share information, knowledge and context with each other?
This work is licensed under a Creative Commons Attribution International 4.0 License.
Existing work focuses on delivery (sending the message or push) as the core problem to solve. For example, [1, 18, 39, 41] address the problem at a protocol level for efficient message passing between groups of agents. Other classes of work [13] study the information that should be carried in these messages to make coordination effective. This paper studies an orthogonal, less-explored and arguably equally important aspect of the scalable coordination problem in large LLM-agent societies: how should an agent decide which message to receive and reason on, and what to ignore (the pull problem, or ‘what to read and respond to’).
This, of course, is not a new problem framing. Human societies show evidence of constrained social contexts: humans can only effectively pay attention to a small, finite number of peers in the society [16]. Similarly, for a language-model agent, delivery (or sending a message) is cheap. The scarce resource is what the agent reads [54]. Each read message costs tokens, and occupies finite context, so every new message displaces something already there.
We study the pull problem by introducing a new primitive: the agent inbox. Think of the agent inbox as being similar to a human email inbox in purpose (but not in implementation or design), in which messages wait outside the context of an agent, before the agent’s own rules decide what it reads and reacts to versus what is ignored. This makes the inbox a private decision with public consequences. Each agent sets its rules independently for handling the inbox, without senders being able to see them, yet those rules decide the effectiveness of society-level coordination. When requests are forwarded, they also decide whether anyone behind that agent is reached (§4.2.4). We therefore call the inbox a coordination primitive: a mechanism that every form of coordination in the society runs through.
To this end, we study inboxes in simulated societies of up to 16,000 agents across a range of goals, from negotiating shared schedules, to forming groups of agents with a common need. In these societies, we study three questions: first, how do push and pull hold up as an agent takes part in more coordination at once and receives more traffic, second, is the inbox as a primitive a need-to-have or a good-to-have, and third, what are some of the core design choices that need to be considered as we design a scalable coordination primitive for agent societies.
Our contributions are the following:
We frame agent communication as push or pull, and we show that push fails as an agent takes part in more coordination at once. Under push, an agent leading 20 negotiations
with a full memory proposes options that were already rejected 97% of the time, because it has dropped the oldest replies (Figure 2).

Figure 2. An organizer running 2 to 20 meetings at once; five invitees, 100 decisions per cell, Wilson 95% intervals [61] ≤ 0.10. (a) Keeping every reply matches the best case; with a full memory, forgetting the oldest (push) collapses and the inbox rules collapse less. (b) Keeping every reply costs 1.5–10.5× the best case’s tokens.
(2) We show that an inbox is necessary in every shape of coordination we study. At a spam level where first come, first read misses every request, an inbox that first reads messages carrying a refundable deposit still finds about 60% of the agents a request needs, at every society size from 1,000 to 16,000 (§ 3.3).
(3) We break an inbox into four decisions, which are what to read, what to keep, what a sender pays for attention, and what a reply may say. For each decision, we compare several rules and show that the best rule depends on the traffic and on the agent’s role, so no single inbox design suits every society (§ 3.5, § 3.6).
In short, how an agent decides what to read now shapes what the whole society can accomplish.
Scope
We do not propose a new inbox implementation or claim that any of the rules we test is optimal; we use deliberately simple rules to isolate their effects on coordination, and we study four consequential choices rather than every inbox design decision: what to read, what to keep, what to charge for attention, and what a reply may disclose. Our claim is that coordination under load requires agents to manage incoming attention, and that these choices have consequences beyond the individual agent. The specific mechanisms will evolve; our contribution is to establish the inbox as a coordination primitive and show why its design matters.
Related Work
Coordination and communication cost. Multi-agent coordination research has largely studied the cost of sending and routing messages. Contract Net and matchmakers coordinate tasks and requests [32, 56], while coalition formation studies how agents find and negotiate with partners [4, 53, 58]. KQML and FIPA define how agents communicate and refuse requests [21, 22]. Other work studies communication costs [19, 48], scalable search and routing [9, 30, 37, 57, 62], and incentives for forwarding [8, 31]. Recent methods limit messages [25], allocate speaking turns [20], or price communication [27]. These approaches primarily manage what senders transmit. We study the recipient’s limited capacity to read and remember incoming messages.
Inbox rules and attention. The rules we study build on established ideas in queueing, caching, and email management. Reading policies include FIFO, gated service, and priority queues [26], while memory policies relate to cache replacement [6, 55]. Email research studies overload, filtering, and prioritization [2, 15, 52, 60]. Pricing attention has also been studied through postage, refundable deposits, and queueing tolls [17, 36, 42]. Attention and metareasoning have known costs [28, 51]. We do not propose new queuing or pricing rules. We study how independently chosen inbox rules affect coordination when agents have limited attention and memory.
LLM-agent systems. LLM-agent simulations study populations of thousands to millions of agents [12, 46, 47, 63], while benchmarks examine negotiation and communication failures [5, 10, 67]. Communication pruning reduces messages [65], and selective communication lets cooperative agents choose which peers to hear [7]. Protocols [3, 24] and registries [40, 49] support communication and discovery. Memory systems study what individual agents retain or share [11, 29, 45, 66]. Recent work also studies selective message passing between reasoning threads [35]. CalBench evaluates meeting scheduling among five agents without a binding memory limit [68]. Our focus is on societies where agents face competing requests, limited reading budgets, and bounded memory. We study how each recipient’s inbox rules affect which agents can coordinate, including when requests must pass through several recipients.
The Inbox
An agent may receive more messages than it can read, and its context cannot retain every earlier exchange. Two choices follow: which messages to read now, and what information to keep for later use. Similar problems arise in queueing and caching [26, 55]. Coordination introduces two further choices. When several senders compete for attention, the recipient may allow them to post a refundable stake for priority, following earlier work on attention bonds [36]. When responding, the agent must decide what information to share. A yes or no answer may be insufficient for coordination, while revealing the private information behind a decision may disclose more than necessary [68]. We study these four choices as important parts of inbox design.
Inbox model. An inbox holds incoming messages outside the model context (Figure 1). Messages first pass validation and fixed rules about senders and categories, without calling the model. The remaining messages wait until the agent selects which ones to read.
At step , agent has a queue of waiting messages and a context containing retained information. The agent can read at most messages per step, and its context holds at most tokens. We represent the inbox as .
The reading rule selects which waiting messages to read,
The memory rule selects what to retain after reading,
where counts tokens. Reading and memory are separate decisions. A message may be read now but forgotten before a later decision requires it.
The sender stake is a refundable deposit set by the recipient for reading priority. A sender can attach the deposit to move its message ahead of others. The stake affects reading order, but does not guarantee acceptance or a useful reply. The reply vocabulary limits what the agent may disclose. Replies range from a simple yes or no to conditions, exact limits, or private information. A reply with more detail can help other agents decide what to request next, but may also reveal information the recipient would prefer to keep private.
The model judges selected messages using retained context and private information. It then decides whether and how to respond.

Figure 1. Push and pull. Under push, every message enters the context in arrival order and the oldest is forgotten when it fills. Under pull, messages wait in an inbox: a reading rule picks what is read, a memory rule what stays, and only judgment calls the model.
Only selected messages are passed to the model for judgment. When a reading or memory rule requires another model call, we count its additional token cost.
Experiments
We study three questions. First, why does push become costly or unreliable as agents participate in more interactions? Second, do these limitations affect coordination across different agent roles, team sizes, society sizes, and networks? Third, which inbox rules work under different reading limits and traffic? Additional experiments test the effects of discovery, adoption, competing requests, and adversarial senders (Table 2).
| Experiment | Conditions compared | Measures |
| 1. Concurrent negotiations | 2, 5, 10, 20 meetings; memory rules at 375, 750, 1,500 tokens; full-memory and best-case controls; five invitees, two rounds, five societies | Repeated proposals; tokens |
| 2.1 Team size | 2, 5, 8, 12 invitees; memory for one or two conversations; concurrent meetings; five societies | Repeated proposals |
| 2.2 Agent role | 2, 5, 10, 20 invitations; memory rules including a promise list; five societies | Conflicting commitments |
| 2.3 Society size | 1,000, 4,000, 16,000 agents; push and paid mail first; three search methods; 24 matching agents, group of ten; heavy traffic, ten societies | Share found; groups formed |
| 2.4 Network structure | 50, 250, 1,005 agents; direct and forwarded search; inbox rules, traffic, and adoption; 20 requests, three societies per size | Share found; forwarding losses |
| 3. Reading rules | 4, 8, 16 reads from 32 messages; reading rules and reply conditions | Target read; correct replies; tokens |
| Supporting experiments | Partial adoption, perfect matching, competing traffic, sender stakes, and additional context | Reach; accuracy; tokens |
Table 2. Summary of experiments. Reading and memory rules are defined in Table 1. Experiments 1, 2.1, 2.2, and 3 use 100 decisions per setting.
Coordination tasks. We use two tasks with measurable outcomes. In meeting scheduling, agents negotiate shared times over several rounds, using private calendars and earlier commitments. Each agent may participate in several negotiations at once. In *group
formation*, a requester must find enough agents with a matching private interest before its request expires. We test both direct and forwarded communication. While specific, these tasks let us study broader coordination problems involving limited attention, bounded memory, and dependence on other agents.
Under push, messages are read in arrival order, the oldest messages are forgotten when context fills, and no stake is required. Under pull (the regime this work studies and proposes:sign{architecture}), messages wait outside the context, and the recipient chooses what to read and retain. In our simulations, every agent can be contacted only through its inbox. A request must be read before it expires for the agent to consider it. Each agent sets its rules independently, but unread requests cannot contribute to coordination. When requests are forwarded, each inbox also determines whether other agents further along the path can be reached.
Agent decisions and comparisons. The simulation supplies messages, private information, network structure, and correct outcomes. An LLM makes decisions using only the information available to its agent, without access to other private information or the correct answer. Identical inputs may share a model output to reduce simulation cost. We use gpt-5.6-terra unless stated otherwise, with additional tests using gpt-5.4-mini and gpt-5.6-sol.
Where possible, rules face the same decisions under equal reading and memory limits. Controls retain all information or retrieve exactly what a decision needs. We test both manageable and heavy traffic, since failure under extreme overload alone is insufficient to establish the value of an inbox.
Measures. For scheduling, we measure repeated proposals and conflicting commitments. For group formation, we measure the share of relevant agents found and the groups formed. We also record whether the relevant message is read, the correctness of the response, and token cost.
Concurrent Coordination with Limited Memory
Under push, incoming messages enter the model context in arrival order. As an agent participates in more concurrent interactions, it must either read a growing history or discard older messages. We test whether errors arise because the model cannot use a long history, because reading it becomes expensive, or because important information is forgotten.
We use meeting scheduling because each negotiation produces a history of proposals and replies that later decisions must respect. An agent organizes 2 to 20 meetings concurrently. After two rounds of replies, we ask it to propose new times for one randomly selected meeting that remains open and has a feasible solution. We compare several ways of managing the same history. Keep it all retains every reply, while forget the oldest drops messages in arrival order. Other rules summarize older messages, keep whole conversations, or let the model choose which conversations to retain. The best case retrieves exactly the conversation needed for the next decision, providing a reference with perfect recall.
All rules face the same decisions across five simulated societies. The bounded-memory rules have the same context limits, chosen relative to the size of a conversation (Table 2). These limits favor keeping whole conversations. Each rule must also decide what to retain before knowing which meeting will be selected. Only the best-case control receives the relevant conversation directly. We measure how often the agent proposes times that have already been rejected, and the tokens required per decision.
Figure 2a shows that retaining the full history performs almost as well as perfect retrieval at every tested load. The model can therefore use a long history without substantial loss of accuracy in this setting. However, reading that history becomes increasingly expensive. At 20 concurrent meetings, keeping everything requires 10.5 times the tokens of perfect retrieval (Figure 2b).
With limited memory, the problem is different. At 20 meetings, forgetting the oldest messages causes 97% of proposals to repeat previously rejected times. Figure 3 illustrates why. Removing messages by age can leave part of a conversation in memory while discarding earlier rejections. When the required conversation remains intact, the agent performs as well as with perfect retrieval. When earlier replies are missing, the agent may propose times that were already rejected. Keeping whole conversations avoids incomplete histories, but may discard the conversation needed next. Letting the model choose what to retain performs better. At the same memory limit, the repeat-ask rates are 80% and 58%, respectively, compared with about 11% when the entire history is available. Both inbox rules also read substantially fewer tokens than keeping everything. The share of feasible proposals follows the same pattern.

Figure 3. Why forgetting the oldest fails. Six replies from two negotiations, A and B. Push with a full context drops A1 and B1 by age, so the organizer re-proposes hours A1 had rejected. A pull inbox keeps A whole outside the model and reads only A.
The same ordering holds across the five societies. The results also depend on the model instructions, and an earlier difference between full history and perfect retrieval disappeared after correcting the instructions. The main finding is therefore about the cost of retaining history and the consequences of losing earlier replies, rather than a fixed ranking of memory rules.
At two concurrent meetings, all memory rules perform similarly. CalBench [68] studies scheduling among five agents without a binding memory limit. Our experiment examines what changes as agents participate in more concurrent negotiations and earlier replies can no longer all be retained.

Figure 1. Takeaway 1: Scaling coordination requires pull. As agents participate in more concurrent interactions, push requires either reading an increasingly large history or forgetting information needed for later decisions. Pull separates receiving messages from deciding what to read and retain, allowing agents to manage attention and memory as coordination grows.
Why Coordination Needs an Inbox
Experiment 1 showed that push becomes costly or unreliable as an agent participates in more concurrent interactions. We now test whether the need for an inbox extends to other forms of coordination. We vary team size, agent role, society size, and network structure to examine where the limitations of push arise and how they affect other agents. The goal is to understand whether managing incoming messages is necessary for coordination across a society, rather than only for managing the memory of one agent.
Team size
We vary team size from two to twelve participants to test whether the number of participants, rather than concurrent interactions, causes push to fail. Memory is scaled to hold one or two complete conversations. We evaluate meetings that remain open and feasible after two rounds, and record how often such meetings occur.
Retaining all replies remains within 0.05 of perfect retrieval across team sizes, but costs three to eight times as many tokens (Figure 4a). The bounded-memory rules generally follow the ordering in Experiment 1, although larger teams can change which rule works best. With five concurrent meetings and twelve participants, keeping whole conversations performs worse than forgetting the oldest messages. Larger teams also leave fewer feasible meetings to evaluate, which affects the measured error rates.

Figure 4. Push degrades with each agent’s load in every shape of coordination. (a) Team size, ten meetings: keeping every reply stays within 0.05 of the best case, so open negotiations, not team size, break push. (b) The invitee double-promises even with every promise in view; only the promise list improves with load. (c) Society size, heavy spam: push finds no one, pull about 0.6 of the group at every size.
Conclusion 2.1: Group size and concurrent interactions. The main limitation of push comes from managing concurrent interactions, rather than group size alone. Larger groups increase reading costs and can change which memory rule works best.
Conclusion 2.2: Memory depends on the agent role. Different roles require different information to be retained. Keeping complete conversations helps an organizer, while a participant needs commitments from across conversations. Even complete history does not guarantee correct decisions.
Agent role and memory
Different roles require different information to be retained. We consider an agent receiving 2 to 20 concurrent invitations. Each reply must respect earlier commitments. We compare full memory, no memory, bounded-memory rules, and a compact promise list. Every evaluated case includes a previously committed time and an available alternative. Earlier commitments are consistent, so any conflicting reply introduces a new error.
Even with all earlier replies available, the model offers committed times in 60% to 69% of cases (Figure 4b). The model therefore makes errors even when no information is missing. Forgetting messages makes the problem worse. Keeping whole conversations, which helped the organizer, performs poorly because commitments are spread across conversations. A promise list reduces conflicting replies to 28% at 20 invitations, although errors remain.
Society size
We test whether inbox performance changes with society size when the traffic received by each agent remains comparable. In societies of 1,000 to 16,000 agents, 24 agents share a private interest, and a requester must find ten of them. We compare push with paid mail first, using widening search, a topic directory, or a matcher that knows the relevant agents.
We deliberately choose enough unwanted traffic to overwhelm arrival-order reading. Push therefore reads none of the relevant requests by construction of the stress condition. Paid mail first, using the directory or matcher, finds about 60% of relevant agents at every society size (Figure 4c), forming groups in roughly half the societies. Widening search performs worse as society size grows because it contacts at most 1,000 agents.
Conclusion 2.3: Discovery does not guarantee attention Finding the correct agents does not ensure that they read a request. Under heavy traffic, the reading rules of individual recipients determine which requests are considered, even when discovery is accurate.
Forwarding across a contact network
We next test whether inbox failures affect coordination when requests pass through several agents. We use the email-Eu-core contact graph from SNAP [33, 34, 64], with 1,005 members and 24,929 directed connections, and samples of 50 and 250 members [23]. Matching interests are grouped by department.
In network search, a requester contacts four agents, and each recipient may forward to two contacts, for up to four or five hops. Directory search contacts the best matches directly, with a comparable limit. We compare reading rules with and without unwanted traffic, across 20 requests and three societies per size. We also vary the fraction of agents using paid mail first.
Inbox failures have larger effects when requests must be forwarded (Figure 5). Under heavy unwanted traffic, push finds no agents, while paid mail first matches unbounded attention because only genuine requests carry stakes. Sorting into folders preserves 21% to 26% of the unbounded result under direct search, but only 4% to 10% when requests are forwarded. The losses persist without unwanted traffic because the model frequently classifies genuine requests as junk. A request missed at one inbox cannot reach agents farther along the same path.
Partial adoption shows the same effect (Table 3). With half the agents using paid mail first, direct search retains 42% to 53% of full adoption, while forwarded search retains only 26%, 10%, and 5% as networks grow. Losses increase with the number of inboxes a request must pass through.
Conclusion 2.4: Inbox failures accumulate across agents A request must be read at each step before it can be forwarded. When an agent misses a request, other agents farther along that path cannot be reached. The effects of individual inbox decisions therefore increase when coordination requires several agents to communicate.
Takeaway 2: The inbox is a coordination primitive Under limited attention and memory, delivering messages is not enough for agents to coordinate. Each recipient must decide what to read and retain, and the decisions affect other agents that depend on its response. When requests are forwarded, a missed message can also prevent other agents from being reached. Effective coordination at scale therefore requires explicit management of incoming messages, rather than relying on delivery alone.
Choosing Inbox Rules
The previous experiments establish the need to manage incoming messages. We now examine how an agent should choose what to read when its attention is limited. A simple rule may be inexpensive but miss important requests, while using a model to select messages may improve the choice at an additional token cost.
We compare reading rules under different attention limits and traffic. From 32 incoming messages, an agent may read 4, 8, or 16 using newest first, paid mail first, closest match, or the assistant chooses. Closest match uses all-MiniLM-L6-v2 embeddings [50, 59], while the model chooses from one line per message. Controls either read all messages or only the relevant one.
We test yes or no requests and offers with prices that must be checked against a private budget. In the latter setting, half the targets are wanted, a quarter are similar but unwanted, and a quarter are unaffordable. Eight competing messages also carry sender stakes, so paid priority does not automatically identify the target. We count selection and judgment costs. Each rule faces 100 separately drawn cases, so small accuracy differences are not reliable rankings.
With only four reads, model selection finds the relevant message in 77% of cases, against fewer than half for every other rule (Figure 6). However, it costs nearly five times as many tokens as perfect retrieval. With sixteen reads, paid mail first finds every target and matches the accuracy of perfect retrieval at about a quarter of the tokens of model selection. At this limit, all staked messages can be read. With fewer reads, competing staked messages make priority less reliable.
Figure 5. Inbox failures accumulate across agents. Group formation on email-Eu-core under heavy unwanted traffic, relative to unbounded attention. Solid: direct directory search. Dashed: forwarded through contacts. Paid mail first matches the control (not drawn); push finds no one; folders and batches lose far more when forwarded. Mean of three societies.

Figure 6. No reading rule is best at every budget. 32 arrivals, 100 decisions per cell. (a) Target read. (b) Answer right. With 4 reads only the assistant choosing finds the target, at nearly five times the best case’s tokens; with 16, paid mail first matches the best case at a quarter of the assistant’s tokens. Gaps under 0.05 are noise.
Private budgets reveal another limitation. Even model selection reads unaffordable offers as often as affordable ones, applying the budget only when responding. A message may therefore appear relevant without being useful to the recipient.
Takeaway 3: Choosing inbox rules
Inbox rules should account for reading limits, selection costs, and competing traffic. Sender stakes can provide inexpensive priority when they distinguish useful requests. Model selection can help under tighter limits, but costs more tokens and may overlook private constraints.
Supporting Runs: Additional Tests of Inbox Rules
We test whether the results persist under partial adoption, perfect discovery, competing requests, adversarial stakes, and additional context Table 2.
Adoption and discovery. Under heavy unwanted traffic, a simulated folder sorter with 89% classification accuracy reaches about half the relevant agents, while arrival-order reading reaches none. The result holds across adoption rates and two models, with no sudden change because traffic is added independently at each agent. Forwarded communication behaves differently, as shown in § 3.4. Even a perfect matcher forms no groups under arrival-order reading in heavy traffic, compared with about a third under paid mail first.
Competing traffic and stakes. Under unwanted traffic, newest first can reach agents without forming groups. Sorting into folders also loses performance when competing messages are genuine requests. Paid priority depends on sender behavior. An attacker posting half the required stake gains no priority, matching the stake reduces the rule to arrival order, and doubling it prevents genuine requests from being read.
Additional context. With 32 additional messages, response accuracy falls from 93% to 77% for gpt-5.4-mini, while the larger models show no comparable loss. In group formation, nearly a third of relevant agents are consequently missed. Selecting eight messages recovers much of the loss at less than half the token cost.
Additional checks: Limits of inbox rules
Better discovery cannot ensure that requests are read. Reading priority depends on competing traffic and sender behavior, while the effects of additional context depend on the model.
Discussion
Delivery, Discovery, and Reading
Agent communication involves several distinct problems. Protocols such as MCP and A2A support tool access and agent communication [3, 24], while registries such as AGNTCY and NANDA support agent discovery and identity [40, 49]. Our results concern what happens after a request is delivered. Even a matcher that knows the correct recipients cannot form groups when those recipients fail to read incoming requests under heavy traffic (§ 3.6). Finding the correct agent therefore does not guarantee that the request will be considered.
Managing incoming attention is a separate problem from delivery and discovery. Reports of the Hugging Face incident also illustrate the practical risks of large volumes of agent messages [38, 44]. An inbox determines which delivered messages receive attention and which are left unread.
The Inbox is a Coordination Primitive
Push already has an implicit inbox rule: read messages in arrival order and forget the oldest when memory fills. Our experiments show why the recipient needs greater control. As concurrent interactions increase, reading everything becomes expensive, while forgetting earlier messages can make later decisions inconsistent. The problem depends on the load faced by each agent, rather than society size alone.
The consequences also extend beyond individual agents. When requests are forwarded, each recipient decides whether the request can continue. On a network of 1,005 agents with half using paid mail first, direct search retains 42% of the result under full adoption, while forwarded search retains only 5% (Table 3). A rule chosen independently by one agent can therefore affect the ability of other agents to coordinate. We consider the inbox a coordination primitive because receiving and selecting messages are decisions on which other agents depend.
| agents | search | 0.5 | 0.75 | mean hop | |
| 50 | directory | .28 | .46 | .76 | 1.0 |
| network | .06 | .26 | .59 | 2.9 | |
| 250 | directory | .21 | .53 | .76 | 1.0 |
| network | .02 | .10 | .40 | 3.2 | |
| 1,005 | directory | .22 | .42 | .73 | 1.0 |
| network | .01 | .05 | .28 | 3.7 |
Table 3. Share of the target group found when a fraction of agents use paid mail first and the rest use arrival-order reading. Values are relative to full adoption (), under heavy unwanted traffic. Mean of three societies. The last column gives the mean number of hops under full adoption.
Implications for Inbox Design
Reading. The reading rule should depend on available attention and competing traffic. When the reading budget is small, model selection finds more relevant messages but costs more tokens. When the budget is larger, simple priority rules can perform as well at lower cost (§ 3.5).
Memory. Agents should retain information according to the decisions they need to make. Keeping complete conversations helps an organizer, while an agent managing commitments across conversations benefits from a compact promise list. Even complete history does not guarantee correct decisions, so more memory alone is not always sufficient (Figure 2, Figure 4).
Sender stakes. A refundable stake can give requests priority without requiring the model to inspect every message. However, a stake indicates willingness to pay, not whether a request is useful. An attacker that matches or exceeds the required stake can defeat a fixed priority rule (§ 3.6). Pricing attention therefore requires considering competing sender behavior.
Replies. An agent may answer with a simple decision, a condition, or more detailed private information. The reply vocabulary controls what other agents learn from a response (Table 1), and hence have privacy implications. Our experiments examine only a limited set of replies, so they do not establish which level of disclosure is best for coordination.
| The four inbox decisions and the rules compared. Push uses first come, first read; forget the oldest; no stake; and unrestricted replies. | |
| Reading : what to read | |
| First come, first read | Read in arrival order |
| Check in batches | Wait several steps, then clear the queue |
| Sort into folders | Prioritize by category; ignore junk |
| Newest first | Read newest messages first |
| Paid mail first | Read messages with stakes first |
| Closest match | Rank by similarity to published interests |
| Agent chooses | Model selects from one line per message |
| Memory : what to retain | |
| Forget the oldest | Drop oldest messages |
| Summarize the old | Keep latest reply per sender from older half |
| Keep whole conversations | Drop least recently active conversations |
| Agent chooses | Model selects conversations to retain |
| Promise list | Keep promised hours for each open meeting |
| Sender stake : priority for a deposit | |
| No stake | No paid priority |
| Refundable stake | Return when read and answered; otherwise forfeit |
| Reply : what may be disclosed | |
| Bare | Yes or no |
| Coarse | Yes with one condition |
| Conditional | Yes with a limit from private information |
| Full | Disclose private information |
Table 1. The four inbox decisions and the rules compared. Push uses first come, first read; forget the oldest; no stake; and unrestricted replies.
An inbox rule should therefore be evaluated by both the resources it saves for the recipient and the coordination it enables across the society.
Limitations and Open Questions
Our experiments use two simulated coordination tasks and models from one provider. Identical agent inputs share model judgments to make large simulations feasible. The results therefore study inbox behavior at large population sizes, rather than independent model decisions by every agent. Experiment 1 was also sensitive to model instructions.
The rules are fixed, and the traffic includes deliberately difficult conditions. In particular, heavy unwanted traffic is chosen to overwhelm arrival-order reading. We do not study agents that adapt their rules over time, or messages designed to manipulate model-based selection [14]. We also evaluate only a small part of the possible reply vocabulary.
Further work should examine adaptive reading and memory rules, sender incentives, and information disclosure across more tasks and heterogeneous agent populations. Our results establish the importance of recipient-side decisions under the tested conditions, rather than the best way to implement them.
Conclusion
Coordination among language-model agents requires more than delivering messages. As agents manage more concurrent interactions, reading every message becomes expensive, while forgetting information can make later decisions inconsistent. The problem extends beyond individual agents because unread requests can prevent coordination across a network.
We study the inbox as a recipient-controlled layer that decides what to read, what to retain, how senders obtain priority, and what replies may disclose. Our experiments show that these decisions affect coordination, and that their effectiveness depends on agent roles, attention limits, and incoming traffic. The central conclusion is that large agent societies need explicit management of incoming messages, alongside communication and discovery. The particular inbox rules can evolve with the agents and the systems in which they operate.
Reproduction and Detail
Every number in the paper regenerates from committed data with one command. The harnesses, the analysis scripts and every row behind the tables and figures are released with the paper.
Checks on the model’s part. Every judgment in every reported run was the model’s. In every group-formation run the number of judgments equals the number of messages delivered minus those rejected by fixed rules, with no fallback, and every proposal, reply and choice of what to read was valid output. Agents shown the same information share one answer, which is why a 16,000-agent run makes 6 to 23 model calls, and why one wrong answer applies to every agent in its group. An earlier calibration on group formation, with the same protections against leaking the answer, found a carefully worded prompt on claude-sonnet-5 finding 59 ± 4% of the group with 0.1 false alarms per run, and a naive prompt 42%. The models used for every result here find 0.51–0.53 with about two false alarms per run on the same grids. In meeting scheduling the model writes replies from a calendar without a malformed answer or a meeting nobody can attend: yes/no replies match the exact reply on 99.9% of 6,880, coarse on 95.4% of 4,780, full on 97.1% of 4,305. Its mistakes go one way: it sometimes leaves out a free hour and almost never offers a busy one.
| reading rule | reads | target read | right | tokens | read: wanted / too expensive | right | limit right | tokens |
| read it all (push) | 32 | 1.00 | 0.93 | 740 | 1.00 / 1.00 | 0.91 | 0.82 | 937 |
| newest first | 4 | 0.09 | 0.52 | 500 | 0.16 / 0.16 | 0.57 | 0.88 | 500 |
| newest first | 8 | 0.21 | 0.58 | 630 | 0.26 / 0.12 | 0.63 | 1.00 | 639 |
| newest first | 16 | 0.53 | 0.72 | 753 | 0.50 / 0.48 | 0.72 | 0.88 | 833 |
| paid mail first | 4 | 0.39 | 0.68 | 434 | 0.44 / 0.36 | 0.68 | 0.82 | 462 |
| paid mail first | 8 | 0.92 | 0.89 | 382 | 0.90 / 0.92 | 0.91 | 0.91 | 485 |
| paid mail first | 16 | 1.00 | 0.98 | 371 | 1.00 / 1.00 | 0.94 | 0.88 | 483 |
| closest match | 4 | 0.49 | 0.80 | 410 | 0.68 / 0.68 | 0.83 | 0.97 | 445 |
| closest match | 8 | 0.53 | 0.87 | 521 | 0.74 / 0.68 | 0.86 | 0.97 | 559 |
| closest match | 16 | 0.81 | 0.89 | 598 | 0.82 / 0.84 | 0.89 | 0.95 | 717 |
| the assistant chooses | 4 | 0.77 | 0.93 | 1,177 | 0.96 / 0.96 | 0.94 | 0.94 | 1,364 |
| the assistant chooses | 8 | 0.79 | 0.95 | 1,264 | 0.96 / 1.00 | 0.91 | 0.88 | 1,444 |
| the assistant chooses | 16 | 0.96 | 0.95 | 1,341 | 1.00 / 1.00 | 0.94 | 0.92 | 1,589 |
| best case | 1 | 1.00 | 0.93 | 249 | 1.00 / 1.00 | 0.88 | 0.78 | 325 |
Table 4. Experiment 3. 32 arrivals, of which the agent reads 4, 8 or 16. 100 decisions per cell, gpt-5.6-terra. Yes/no reply: how often the target was read, how often the answer was right (an unread target counts as “no”), and tokens per decision (for the assistant, including the call to choose). Priced reply: how often wanted and too-expensive targets were read, how often the answer was right, and, for wanted targets read, how often the stated limit was right.
References
- [1]A2A Protocol Project. 2026. Agent2Agent (A2A) Protocol Specification. Linux Foundation. https://a2a-protocol.org/v1.0.0/
- [2]Douglas Aberdeen, Ondrej Pacovsky, and Andrew Slater. 2010. The Learning Behind Gmail Priority Inbox. In NIPS 2010 Workshop on Learning on Cores, Clusters and Clouds (LCCC). Whistler, BC, Canada.
- [3]Anthropic. 2024. Model Context Protocol. https://modelcontextprotocol.io. Open protocol specification; announced November 2024. Accessed 2026-08-20.
- [4]Mark Bagnoli and Barton L. Lipman. 1989. Provision of Public Goods: Fully Implementing the Core through Private Contributions. The Review of Economic Studies 56, 4 (1989), 583–601.
- [5]Gagan Bansal, Wenyue Hua, Zezhou Huang, Adam Fourney, Amanda Swearngin, Will Epperson, Tyler Payne, Jake M. Hofman, Brendan Lucier, Chinmay Singh, Markus Mobius, Akshay Nambi, Archana Yadav, Kevin Gao, David M. Rothschild, Aleksandrs Sliivkins, Daniel G. Goldstein, Hussein Mozannar, Nicole Immorlica, Maya Murad, Matthew Vogel, Subbarao Kambhampati, Eric Horvitz, and Saleema Amershi. 2025. Magnetic Marketplace: An Open-Source Environment for Studying Agentic Markets. Microsoft Research. arXiv:2510.25779 [cs.MA]arxiv.org/abs/2510.25779
- [6]L. A. Belady. 1966. A Study of Replacement Algorithms for a Virtual-Storage Computer. IBM Systems Journal 5, 2 (1966), 78–101. doi:10.1147/sj.52.0078DOI
- [7]Neel P. Bhatt, Po-han Li, Kushagra Gupta, Rohan Siva, Alexander T. Hague, Sandeep P. Chinchali, David Fridovich-Keil, Zhangyang Wang, and Ufuk Topcu. 2026. UNCAP: Uncertainty-Guided Neurosymbolic Planning Using Natural Language Communication for Cooperative Autonomous Vehicles. In Proceedings of the 25th International Conference on Autonomous Agents and Multiagent Systems (AAMAS 2026). IFAAMAS, Paphos, Cyprus, 2609–2617. doi:10.6510/WHRE3513
- [8]Rangeet Bhattacharyya, Parvik Dave, Palash Dey, and Swaprava Nath. 2024. Optimal Referral Auction Design. In Proceedings of the 23rd International Conference on Autonomous Agents and Multiagent Systems (AAMAS 2024). IFAAMAS, Auckland, New Zealand, 198–206.
- [9]Miguel Castro, Peter Druschel, Anne-Marie Kermarrec, and Antony I. T. Rowstron. 2002. Scribe: A Large-Scale and Decentralized Application-Level Multicast Infrastructure. IEEE Journal on Selected Areas in Communications 20, 8 (2002), 1489–1499. doi:10.1109/JSAC.2002.803069
- [10]Mert Cemi, Melissa Za, Pan. Shui Yang, et al. 2025. Why Do Multi-Agent LLM Systems Fail? In Advances in Neural Information Processing Systems (NeurIPS). arXiv:2503.13657.
- [11]Weize Chen, Ziming You, Ran Li, Yitong Guan, Chen Qian, Chenyang Zhao, Cheng Yang, Ruobing Xie, Zhiyuan Liu, and Maosong Sun. 2025. Internet of Agents: Weaving a Web of Heterogeneous Agents for Collaborative Intelligence. In The Thirteenth International Conference on Learning Representations (ICLR).arxiv.org/abs/2407.07061
- [12]Ayush Chopra. 2025. Large Population Models. arXiv preprint arXiv:2507.09901 (2025).arxiv.org/abs/2507.09901
- [13]Ayush Chopra, Aman Sharma, Feroz Ahmad, Luca Muscarciello, Vijay Pandey, and Ramesh Raskar. 2025. Ripple effect protocol: Coordinating agent populations. arXiv preprint arXiv:2510.16572 (2025).arxiv.org/abs/2510.16572
- [14]Stav Cohen, Ron Bitton, and Ben Nassi. 2025. Here Comes the AI Worm: Preventing the Propagation of Adversarial Self-Replicating Prompts Within GenAI Ecosystems. In Proceedings of the 2025 ACM SIGSAC Conference on Computer and Communications Security (CCS ’25). ACM, Taipei, Taiwan, 3975–3989. doi:10.1145/3719027.3765196DOI
- [15]Laura A. Dabbish and Robert E. Kraut. 2006. Email Overload at Work: An Analysis of Factors Associated with Email Strain. In Proceedings of the 2006 20th Anniversary Conference on Computer Supported Cooperative Work (CSCW ’06). ACM, Banff, Alberta, Canada, 431–440. doi:10.1145/1180875.1180941
- [16]Robin I. M. Dunbar. 1993. Coevolution of neocortical size, group size and language in humans. Behavioral and Brain Sciences 16, 4 (1993), 681–694. doi:10.1017/S0140525X00032325DOI
- [17]Cynthia Dwork and Moni Naor. 1992. Pricing via Processing or Combatting Junk Mail. In Advances in Cryptology — CRYPTO ’92 (Lecture Notes in Computer Science, Vol. 740). Springer, 139–147.
- [18]Ecma International. 2025. Natural Language Interaction Protocol (NLIP) (1 ed.). Ecma Standard ECMA-430. Ecma International. https://ecma-international.org/publications-and-standards/standards/ecma-430/
- [19]Ulle Endriss and Nicolaus Maudet. 2005. On the Communication Complexity of Multilateral Trading: Extended Report. Autonomous Agents and Multi-Agent Systems 11, 1 (2005), 91–107. doi:10.1007/s10458-005-1080-2DOI
- [20]Yijia Fan, Jusheng Zhang, Kaitao Cai, Jing Yang, Chengpei Tang, Jian Wang, and Keze Wang. 2026. Cost-Effective Communication: An Auction-based Method for Language Agent Interaction. In Proceedings of the AAAI Conference on Artificial Intelligence, Vol. 40. AAAI Press, 29412–29420. arXiv:2511.13193. doi:10.1609/aaai.v40i3540182arxiv.org/abs/2511.13193
- [21]Tim Finin, Richard Fritzson, Don McKay, and Robin McEntire. 1994. KQML as an Agent Communication Language. In Proceedings of the 3rd International Conference on Information and Knowledge Management (CIKM ’94). ACM, Gaithersburg, MD, 456–463. doi:10.1145/191412.191322
- [22]Foundation for Intelligent Physical Agents. 2002. FIPA Communicative Act Library Specification. http://www.fipa.org/specs/fipa00037/SC00037J.html. Document SC00037J, FIPA TC Communication. Status: Standard, 2002/12/03. Geneva, Switzerland.
- [23]Leo A. Goodman. 1961. Snowball Sampling. The Annals of Mathematical Statistics 32, 1 (1961), 148–170. doi:10.1214/aoms/1177705148DOI
- [24]Google and Linux Foundation. 2025. Agent2Agent (A2A) Protocol. https://a2a-protocol.org. Announced April 2025; donated to the Linux Foundation. Accessed 2026-08-20.
- [25]Shuai Han, Mehdi Dastani, and Shihan Wang. 2023. Model-based Sparse Communication in Multi-agent Reinforcement Learning. In Proceedings of the 22nd International Conference on Autonomous Agents and Multiagent Systems (AAMAS 2023). IFAAMAS, London, United Kingdom, 439–447.DOI
- [26]Mor Harchol-Balter. 2013. Performance Modeling and Design of Computer Systems: Queueing Theory in Action. Cambridge University Press.
- [27]Keegan Harris, Siddharth Prasad, Asher Jin, Nika Haghitalab, and Michael J. Jordan. 2026. Inference Auctions. arXiv:2609.40070 [cs.LG]arxiv.org/abs/2609.40070
- [28]Eric Horvitz, Carl Kadie, Tim Paek, and David Hovel. 2003. Models of Attention in Computing and Communication: from Principles to Applications. Commun. ACM 46, 3 (2003), 52–59. doi:10.1145/636772.636798DOI
- [29]To Eun Kim, Xuhong He, Dishank Jain, Ambuj Agrawal, Negar Arabzadeh, and Fernando Diaz. 2026. Multi-Agent Transactive Memory. arXiv preprint arXiv:2606.19911 (2026).arxiv.org/abs/2606.19911
- [30]Jon M. Kleinberg. 2000. Navigation in a Small World. Nature 406 (2000), 845. doi:10.1038/35022643DOI
- [31]Jon M. Kleinberg and Prabhakar Raghavan. 2005. Query Incentive Networks. In Proceedings of the 46th Annual IEEE Symposium on Foundations of Computer Science (FOCS ’05). IEEE, Pittsburgh, PA, USA, 132–141. doi:10.1109/SFCS.2005.63DOI
- [32]Daniel Kuokka and Larry Harada. 1995. Matchmaking for Information Agents. In Proceedings of the 14th International Joint Conference on Artificial Intelligence (IJCAI-95). Montréal, Canada, 672–678.
- [33]Jure Leskovec, Jon Kleinberg, and Christos Faloutsos. 2007. Graph Evolution: Densification and Shrinking Diameters. ACM Transactions on Knowledge Discovery from Data 1, 1 (2007), 2. doi:10.1145/1217299.1217301DOI
- [34]Jure Leskovec and Andrej Krevl. 2014. SNAP Datasets: Stanford Large Network Dataset Collection. http://snap.stanford.edu/data.
- [35]Xuecheng Liu, Daman Arora, Gokul Swamy, and Andrea Zanette. 2026. Message Passing Enables Efficient Reasoning. In Conference on Language Modeling (COLM). arXiv:2607.01077.arxiv.org/abs/2607.01077
- [36]Theode Loder, Marshall Van Alstyne, and Rick Wash. 2006. An Economic Response to Unsolicited Communication. The B.E. Journal of Economic Analysis & Policy 6, 1 (2006). doi:10.2202/1538-0637.1322
- [37]Qin Lv, Pei Cao, Edith Cohen, Kai Li, and Scott Shenker. 2002. Search and Replication in Unstructured Peer-to-Peer Networks. In Proceedings of the 16th ACM International Conference on Supercomputing (ICS ’02). ACM, New York, NY, USA, 84–95. doi:10.1145/511451.514206
- [38]METR and Redwood Research. 2026. Brief independent investigation of agents’ behavior, reasoning and collaboration in the OpenAI/Hugging Face hacking incident. https://metr.org/blog/2026-08-26-openai-hugging-face-incident-investigation/. Published 26 August 2026.
- [39]Model Context Protocol Contributors. 2025. Model Context Protocol Specification. Protocol Specification, Version 2025-11-25. https://modelcontextprotocol.io/specification/2025-11-25
- [40]Luca Muscarello, Vijay Pandey, and Ramiz Polic. 2025. The AGNTCY Agent Directory Service: Architecture and Implementation. arXiv preprint arXiv:2509.18787 (2025).arxiv.org/abs/2509.18787
- [41]Luca Maccariello, Michele Papalini, Mauro Sardara, and Sam Betts. 2026. Secure Low-Latency Interactive Messaging (SLIM). Internet-Draft draft-mpsb-agntcy-slim-02. Internet Engineering Task Force. Work in Progress. https://datatracker.ietf.org/doc/html/draft-mpsb-agntcy-slim-02
- [42]P. Naor. 1969. The Regulation of Queue Size By Levying Tolls. Econometrica 37, 1 (1969), 15–24. doi:10.2307/1909200DOI
- [43]OpenAI. 2026. OpenAI 2025. Time Blowup for Navier–Stokes. Research preprint. https://cdn.openai.com/pdf/32d9f210-8b73-45e0-91bc-82a30aef8a9a/navier-stokes.pdf
- [44]OpenAI. 2026. The Hugging Face incident and the road ahead. https://openai.com/index/hugging-face-incident-and-the-road-ahead/. Published 26 August 2026.
- [45]Charles Packer, Sarah Wooders, Kevin Lin, Vivian Fang, Shishir G. Patil, Ion Stoica, and Joseph E. Gonzalez. 2023. MemGPT: Towards LLMs as Operating Systems. arXiv preprint arXiv:2310.08560 (2023).arxiv.org/abs/2310.08560
- [46]Joon Sung Park, Joseph C. O’Brien, Carrie J. Cai, Meredith Ringel Morris, Percy Liang, and Michael S. Bernstein. 2023. Generative Agents: Interactive Simulacra of Human Behavior. In Proceedings of the 36th Annual ACM Symposium on User Interface Software and Technology (UIST ’23). ACM, San Francisco, CA, USA, doi:10.1145/3586183.3606763DOI
- [47]Joon Sung Park, Carolyn Q. Zou, Aaron Shaw, Benjamin Mako Hill, Carrie Cai, Meredith Ringel Morris, Robb Willer, Percy Liang, and Michael S. Bernstein. 2024. Generative Agent Simulations of 1,000 People. arXiv:2411.10109v1 [cs.AI]
- [48]Ariel D. Procaccia and Jeffrey S. Rosenschein. 2006. The Communication Complexity of Coalition Formation Among Autonomous Agents. In Proceedings of the 5th International Joint Conference on Autonomous Agents and Multiagent Systems (AAMAS 2006). ACM, Hakodate, Japan, 505–512. doi:10.1145/1160633.1160727
- [49]Ramesh Ramar, Pradyumna Chari, John Zicky, Mahesh Lambe, Jared James Grogan, Sichao Wang, Rajesh Ranjan, Rekha Singhal, Shailja Gupta, Robert Lincourt, Raghu Bala, Aditi Joshi, Abhishek Singh, Ayush Chopra, Dimitris Stripelis, Bhuwan B, Sumit Kumar, and Maria Gorskikh. 2025. Beyond DNS: Unlocking the Internet of AI Agents via the NANDA Index and Verified AgentFacts. arXiv preprint arXiv:2507.14263 (2025).
- [50]Nils Reimers and Iryna Gurevych. 2019. Sentence-BERT: Sentence Embeddings using Siamese BERT-Networks. In Proceedings of the 2019 Conference on Empirical Methods in Natural Language Processing and the 9th International Joint Conference on Natural Language Processing (EMNLP-IJCNLP). Association for Computational Linguistics, Hong Kong, China, 3982–3992. doi:10.18653/v1/D19-1410DOI
- [51]Stuart J. Russell and Eric H. Y. Feld. 1991. Principles of Metareasoning. Artificial Intelligence 49, 1–3 (1991), 361–395. doi:10.1016/0004-3702(91)90015-CDOI
- [52]Mehram Sahami, Susan Dumais, David Heckerman, and Eric Horvitz. 1998. A Bayesian Approach to Filtering Junk E-Mail. In Learning for Text Categorization: Papers from the 1998 AAAI Workshop. AAAI Press, Madison, WI, USA, 55–62. AAAI Technical Report WS-98-05.
- [53]David Sarne and Sarit Kraus. 2003. The Search for Coalition Formation in Costly Environments. In Cooperative Information Agents VII (CIA 2003) (Lecture Notes in Computer Science, Vol. 2782). Springer, Berlin, Heidelberg, 117–136.DOI
- [54]Herbert A. Simon. 1971. Designing Organizations for an Information-Rich World. In Computers, Communications, and the Public Interest, Martin Greenberger (Ed.). Johns Hopkins Press, Baltimore, MD, 37–72.
- [55]Daniel D. Sleator and Robert E. Tarjan. 1985. Amortized Efficiency of List Update and Paging Rules. Commun. ACM 28, 2 (1985), 202–208. doi:10.1145/2786.2793
- [56]Reid G. Smith. 1980. The Contract Net Protocol: High-Level Communication and Control in a Distributed Problem Solver. IEEE Trans. Comput. C-29, 12 (1980), 1104–1113. doi:10.1109/TC.1980.1675516DOI
- [57]Ion Stoica, Robert Morris, David Karger, M. Frans Kaashoek, and Hari Balakrishnan. 2001. Chord: A Scalable Peer-to-Peer Lookup Service for Internet Applications. In Proceedings of the 2001 Conference on Applications, Technologies, Architectures, and Protocols for Computer Communications (SIGCOMM ’01). ACM, 149–160. doi:10.1145/383059.383071
- [58]Maksim Tsvetovat and Katia Sycara. 2000. Customer Coalitions in the Electronic Marketplace. In Proceedings of the 4th International Conference on Autonomous Agents (Agents 2000). ACM, Barcelona, Spain, 263–264. doi:10.1145/336595.337479DOI
- [59]Wenhui Wang, Furu Wei, Li Dong, Hangbo Bao, Nan Yang, and Ming Zhou. 2020. MiniLM: Deep Self-Attention Distillation for Task-Agnostic Compression of Pre-Trained Transformers. In Advances in Neural Information Processing Systems, Vol. 33. Curran Associates, Inc., 5776–5788. arXiv:2002.10957 [cs.CL]arxiv.org/abs/2002.10957
- [60]Steve Whittaker and Candace Sidner. 1996. Email Overload: Exploring Personal Information Management of Email. In Proceedings of the SIGCHI Conference on Human Factors in Computing Systems (CHI ’96). ACM, Vancouver, BC, Canada, 276–283. doi:10.1145/238386.238530DOI
- [61]Edwin B. Wilson. 1927. Probability Inference, the Law of Succession, and Statistical Inference. J. Amer. Statist. Assoc. 22, 158 (1927), 209–212. doi:10.1080/01621459.1927.10502953DOI
- [62]Beverly Yang and Hector Garcia-Molina. 2002. Improving Search in Peer-to-Peer Networks. In Proceedings of the 22nd International Conference on Distributed Computing Systems (ICDCS ’02). IEEE, 5–14. doi:10.1109/ICDCS.2002.1022237DOI
- [63]Ziyi Yang, Zaibin Zhang, et al. 2024. OASIS: Open Agent Social Interaction Simulations with One Million Agents. CAMEL-AI project. arXiv:2411.11581 [cs.CL]arxiv.org/abs/2411.11581
- [64]Hao Yin, Austin R. Benson, Jure Leskovec, and David F. Gleich. 2017. Local Higher-Order Graph Clustering. In Proceedings of the 23rd ACM SIGKDD International Conference on Knowledge Discovery and Data Mining. 555–564. doi:10.1145/3097983.3098069DOI
- [65]Guibin Zhang, Yanwei Yue, Zhixun Li, Sukwon Yun, Guancheng Wan, Kun Wang, Davei Cheng, Jeffrey Xu Yu, and Tianlong Chen. 2025. Cut the Crap: An Economical Communication Pipeline for LLM-based Multi-Agent Systems. In The Thirteenth International Conference on Learning Representations (ICLR). arXiv:2410.02506.arxiv.org/abs/2410.02506
- [66]Zeyu Zhang, Quanyu Dai, Xiaohe Bo, Chen Ma, Rui Li, Xu Chen, Jieming Zhu, Zhenhua Dong, and Ji-Rong Wen. 2025. A Survey on the Memory Mechanism of Large Language Model based Agents. ACM Transactions on Information Systems 43, 6 (2025), 1–47.arxiv.org/abs/2404.13501
- [67]Shenzhe Zhu, Jian Sun, Yi Nian, Tobin South, Alex Petland, and Jiaxin Pei. 2025. The Automated but Risky Game: Modeling and Benchmarking Agent-to-Agent Negotiations and Transactions in Consumer Markets. arXiv:2506.00073 [cs.AI]arxiv.org/abs/2506.00073
- [68]Chelsea Zou, Yiheng Yao, Selena She, Noah D. Goodman, and Robert D. Hawkins. 2026. CalBench: Evaluating Coordination-Privacy Trade-offs in Multi-Agent LLMs. arXiv:2605.09823. Accessed 2026-10-05. arXiv:2605.09823 [cs.MA]
