Paper deep dive

Capability Advertisement as a Market for Lemons: A Trust Layer for Heterogeneous Agent Networks

Gaurav Naresh Mittal

Year: 2026Venue: arXiv preprintArea: cs.MAType: PreprintEmbeddings: 59

Intelligence

Status: succeeded | Model: Gemma-4-26B-A4B | Prompt: intel-v1 | Confidence: 94%

Last extracted: 7/9/2026, 12:47:17 AM

Summary

This paper identifies a 'market for lemons' dynamic in heterogeneous LLM agent networks, where protocols like MCP and A2A assume static, truthful capability advertisements. It introduces 'confident-wrong' as a non-adversarial, correlated Byzantine fault and proposes a 'Trust Layer' that adds probabilistic capability descriptors, screening via challenges and attestation, and reputation with drift detection. These mechanisms aim to establish a separating equilibrium, improve delegation reliability, and gracefully handle asymmetric information without requiring model retraining.

Entities (9)

Trust Layer · architecture · 99%Agent2Agent Protocol (A2A) · protocol · 98%Model Context Protocol (MCP) · protocol · 98%Market for Lemons · economic-concept · 97%Confident-Wrong Fault · fault-type · 96%Probabilistic Capability Descriptors · mechanism · 94%Screening · mechanism · 93%Attestation · mechanism · 92%Reliability-Composition Bound · theoretical-result · 91%

Relation Signals (8)

Trust Layer → implements → Probabilistic Capability Descriptors

confidence 96% · The Trust Layer, a thin, protocol-agnostic narrow waist above MCP and A2A that adds probabilistic capability descriptors, screening, and reputation

A2A → assumes → static truthful capability

confidence 95% · These protocols assume an advertised capability is a static, truthful fact.

MCP → assumes → static truthful capability

confidence 95% · These protocols assume an advertised capability is a static, truthful fact.

Trust Layer → implements → Screening

confidence 95% · adds probabilistic capability descriptors, screening, and reputation as a narrow waist above MCP and A2A

Confident-Wrong Fault → causes → Market for Lemons

confidence 94% · When quality is hidden and claims are cheap, good and bad providers become indistinguishable, honest reliability goes unrewarded, and the market decays toward its worst participants.

Trust Layer → enables → Separating Equilibrium

confidence 94% · admits a separating equilibrium when the cost of sustaining an overclaim exceeds the gain from it

Screening → utilizes → Attestation

confidence 93% · screening through challenges and third-party attestation

Reliability-Composition Bound → →

Cypher Suggestions (0)

No Cypher suggestions yet.

Abstract

Abstract:Large language model (LLM) agents have begun to delegate work to one another. Protocols such as the Model Context Protocol (MCP) and the Agent2Agent protocol (A2A) let an agent publish what it can do and let others call it, and public registries of such agents are already appearing. These protocols assume an advertised capability is a static, truthful fact. A real agent is none of these things: its competence is probabilistic, varies with input, drifts when the underlying model is updated, and, because the agent is itself a language model, it can describe itself with complete confidence and be wrong. A caller therefore sees what an agent claims to do, not what it can do, with no principled way to tell a reliable provider from a fluent impostor. We argue these difficulties share one cause: the market for lemons. When quality is hidden and claims are cheap, good and bad providers become indistinguishable, honest reliability goes unrewarded, and the market decays toward its worst participants. Economics offers three remedies, signaling, screening, and reputation, and none are present in today's agent protocols. We make four contributions: (1) a failure taxonomy that names confident-wrong as a non-adversarial, correlated subclass of Byzantine faults that classical fault-tolerance mismodels; (2) a market-for-lemons model showing that faith-based protocols admit only a low-trust equilibrium; (3) the Trust Layer, a thin, protocol-agnostic narrow waist above MCP and A2A that adds probabilistic capability descriptors, screening, and reputation, and admits a separating equilibrium when the cost of sustaining an overclaim exceeds the gain from it; and (4) a reliability-composition bound for delegation chains with an end-to-end placement argument. The design needs no model retraining and degrades gracefully when its trust anchors are absent or corrupt.

PDF

Open source PDF →Open local PDF →

Trouble viewing inline? Open PDF directly →

Full Text

58,749 characters extracted from source content.

Expand or collapse full text

Capability Advertisement as a Market for Lemons: A Trust Layer for Heterogeneous Agent Networks Gaurav Naresh Mittal gaurav.n.mittal@gmail.com Abstract Large language model (LLM) agents have begun to delegate work to one another. Protocols such as the Model Context Protocol (MCP) and the Agent2Agent protocol (A2A) let an agent publish what it can do and let other agents call it, and public registries of such agents are already appearing. These protocols share an assumption inherited from a friendlier era of distributed computing: that an advertised capability is a static, truthful fact. A real agent is none of these things. Its competence is probabilistic, it varies with the input, it drifts when the underlying model is updated, and—because the agent is itself a language model—it can describe itself with complete confidence and be wrong. A caller therefore sees what an agent claims to do, not what it can do, and has no principled way to tell a reliable provider from a fluent impostor. We argue that these difficulties share a single, well-understood cause: the market for lemons. When quality is hidden and claims are cheap, good and bad providers become indistinguishable, honest reliability goes unrewarded, and the market decays toward its worst participants. The same forces operate in an open agent network. Read this way, the cure is also known. Economics offers three remedies—signaling, screening, and reputation—and none of them are present in today’s agent protocols. We make four contributions. First, we give a failure taxonomy for heterogeneous agent networks that names confident-wrong—a non-adversarial, correlated subclass of Byzantine faults that classical fault-tolerance mismodels—as the characteristic failure of this setting. Second, we model capability advertisement as a lemons market and argue that faith-based protocols admit only a low-trust equilibrium. Third, we propose the Trust Layer: a thin, protocol-agnostic layer that adds probabilistic capability descriptors, screening, and reputation as a narrow waist above MCP and A2A, and we show analytically that it admits a separating equilibrium under a stated condition. Fourth, we give a reliability-composition bound for delegation chains and invoke the end-to-end argument to delimit what such a layer can and cannot promise. The design needs no model retraining and degrades gracefully when its trust anchors are absent or corrupt. Keywords: agent protocols, capability advertisement, heterogeneous multi-agent systems, trust and reputation, asymmetric information, LLM reliability, distributed-systems failure models. 1 Introduction Consider a planning agent assembling a contract review. It runs on a capable model, it has a budget, and it would rather not do everything itself, so it decomposes the job and looks for help. One subtask—summarize the indemnification clauses—is delegated to another agent it found in a registry. That agent advertises exactly this skill. It accepts the task, works for a few seconds, and returns a clean, well-organized summary. The planner folds the result into the final document and moves on. The summary is wrong. The delegated agent runs on a smaller, cheaper model that produces fluent legal prose without reliably tracking which party indemnifies which. Nothing in the exchange revealed this. There was no exception, no timeout, no malformed response—only a confident answer that happened to be false. The planner had no signal that anything had gone wrong, because the protocol gave it no channel in which such a signal could even be expressed. This is not an exotic edge case. As agents increasingly call agents they did not build and cannot inspect, the exchange above becomes the common case rather than the cautionary one. Public directories of MCP servers and A2A agents are multiplying, and the agents behind them sit on a heterogeneous mix of model families, fine-tunes, and scaffolds whose reliability profiles differ enormously and are not observable from the outside. Why the obvious fixes do not work. The natural reaction is to ask the agent how good it is. But self-assessment is the problem, not the solution: language models are poorly calibrated about their own competence, and an open network gives every provider an incentive to describe itself generously. A second reaction is to test the agent, which helps but is expensive to do well and says nothing about tomorrow, because a provider can silently swap the model behind a stable advertisement, so a system can quietly degrade from one week to the next. A third reaction is to treat a bad answer as a fault and route around it, but classical failure models have no category for an answer that is live, responsive, protocol-compliant, and wrong with high fluency. The insight. Each of these difficulties is a symptom of one underlying condition. The caller observes an advertised capability but not the true one; the two can diverge; and the provider, not the caller, knows which is which. This is asymmetric information, and its canonical analysis is Akerlof’s market for lemons [Akerlof 1970]. In a lemons market, buyers who cannot distinguish quality will pay only for the average, good sellers withdraw because the average underprices them, the average falls, and the market unravels toward its worst goods. An open agent network has the same structure: a provider who invests in genuine reliability emits an advertisement indistinguishable from an overclaimer’s, earns no premium for the investment, and is selected against. The equilibrium is a market of lemons. Naming the problem this way is useful because it imports a solution. The economics of asymmetric information did not stop at the diagnosis; it produced three remedies—signaling [Spence 1973], screening [Rothschild and Stiglitz 1976], and reputation in repeated interaction [Resnick et al. 2000]. Strikingly, none of these mechanisms exist in current agent protocols, and, by the end-to-end argument [Saltzer et al. 1984], none of them belong inside the wire protocol; they belong in a thin layer above it. That layer is the subject of this paper. Contributions. 1. A failure taxonomy for heterogeneous agent networks that isolates confident-wrong (capability overclaim)—a non-adversarial, correlated subclass of Byzantine faults that classical fault-tolerance mismodels—and maps each fault to an observable signal (Section 3). 2. A market-for-lemons model of capability advertisement, with an argument that faith-based protocols—those that accept advertised capability at face value—admit only a low-trust, pooling equilibrium (Sections 3 and 4.5). 3. The Trust Layer, a protocol-agnostic design that adds probabilistic capability descriptors, screening through challenges and third-party attestation, and reputation with drift detection, composed as a narrow waist above MCP and A2A. We argue it admits a separating equilibrium when the cost of screening exceeds the gain from overclaiming, and that it degrades gracefully when its trust anchors are weak or absent (Section 4). 4. A reliability-composition bound for delegation chains and an end-to-end placement argument for what the layer should and should not promise (Section 4.6). The contribution is conceptual rather than experimental: we recognize an isomorphism and adapt mechanisms with known properties. Section 6 is therefore an analysis—equilibrium arguments, composition bounds, and grounding in published benchmarks—rather than a report of new measurements, and we are explicit about the difference. The remainder of the paper covers background and the cooperative-capability assumption (Section 2), the lemons formulation (Section 3), the design (Section 4), a mapping onto existing protocols (Section 5), analysis (Section 6), related work (Section 7), discussion (Section 8), and conclusions (Section 9). 2 Agent Protocols and the Cooperative-Capability Assumption Today’s agent protocols describe capability as a schema. In A2A, an agent publishes an agent card listing skills; in MCP, a server exposes tools, each with a name, a description, and a typed input/output schema; OpenAI-style function calling does much the same. These designs are good at what they were built for: telling a caller how to invoke a capability—what arguments to pass, what shape of result to expect. They say nothing about whether the call will succeed. The omission is structural. A tool schema is a boolean assertion: the capability is present or it is not. There is no field for how often the tool returns a correct result, no way to say that accuracy falls off past a certain input length or outside a certain domain, no record of what evidence backs the claim, and no expiry date after which the claim should be re-checked. A reliable agent and a confident overclaimer therefore publish the same advertisement. Table 1 summarizes the gap. Table 1: What current advertisements express (∙ present, ∘ absent). Protocol Invocation Reliability Context- Provenance Freshness Trust schema dependence signal MCP tools ∙ ∘ ∘ ∘ ∘ ∘ A2A agent cards ∙ ∘ ∘ ∘ ∘ ∘ Function calling ∙ ∘ ∘ ∘ ∘ ∘ System model. We consider an open network in which any party may publish an agent and any party may call one. An agent is a backend (a model, possibly fine-tuned) wrapped in a scaffold (tools, prompts, control logic). Agents delegate tasks to one another, forming a directed delegation graph whose depth is not bounded in advance. A caller cannot inspect a callee’s backend or scaffold; it sees only the advertisement and the responses. We assume interactions repeat and that agent identities persist long enough to accumulate history—assumptions we return to in Section 6.5, because the design leans on them. Why the classical failure model is not enough. Dependable-systems theory classifies faults as crash, omission, timing, or Byzantine [Avizienis et al. 2004, Lamport et al. 1982]. A confident-wrong answer is, formally, a Byzantine fault: arbitrary incorrect output is exactly what that model admits. The trouble is that the standard Byzantine response fits this setting poorly. Byzantine fault tolerance assumes worst-case, adversarial behavior and defends against it with replication that tolerates a bounded fraction of failures, on the assumption that those failures are independent. Confident-wrong faults honor neither premise. They are not adversarial; they are faithful reports of mistaken beliefs. And they are far from independent: agents that share training data and prompts tend to fail on the same inputs in the same way, so a supermajority can be confidently wrong together and voting buys little. The binary honest-or-faulty abstraction also discards the quantity that matters most in practice, which is how likely a given answer is to be correct. We therefore treat confident-wrong not as a fault outside the Byzantine class but as the subclass this setting is made of—non-adversarial, correlated, and probabilistic—and one that the machinery built for the general case mismodels. Section 3 gives it a name and a place among the other faults. 3 The Lemons Market in Capability Advertisement 3.1 An example that compounds Return to the contract-review planner, but let it delegate down a chain rather than to a single agent. The planner asks Agent A to extract obligations; A delegates clause summarization to B; B calls C to resolve cross-references. Each agent advertises the relevant skill, and each returns a confident, plausible result. No hop reports trouble. Yet the probability that the final answer is correct is the product of the per-hop reliabilities, and a chain of three agents that are each right 85% of the time is correct only about 61% of the time. The error is invisible at every step and severe end to end. Heterogeneity makes this worse, not better: the agents fail in different, sometimes correlated ways, so the planner cannot even assume that a second opinion is independent. 3.2 The problem, stated Let an agent i have a true reliability ri∈[0,1]r_i∈[0,1] on a task class—the probability that its result is correct—possibly a function ri(x)r_i(x) of input features x such as length or domain. Let aia_i be the agent’s advertised capability. In current protocols aia_i is a bit (the skill is listed or not), and crucially the caller observes aia_i, never rir_i. Providers may set aia_i strategically; nothing prevents an agent of low rir_i from advertising the same skill as one of high rir_i. This is the lemons setup. Because the caller cannot observe rir_i, it can offer only an average level of trust to everyone advertising a given skill. That average underrewards a high-rir_i provider, who must pay—in compute, in careful scaffolding, in evaluation—to be reliable while earning no more than an overclaimer who pays nothing. The high-reliability provider’s rational move is to stop paying. As reliable providers withdraw or stop investing, the average falls, and the network selects for confident overclaimers. Absent a mechanism that ties trust to truth, the faith-based protocol has a single stable outcome, and it is the bad one. 3.3 A failure taxonomy To reason about mechanisms we first need vocabulary for what can go wrong. We distinguish: • Crash—the agent does not respond. • Timeout / omission—the agent is too slow or drops the request. • Refusal—the agent declines (policy, safety, or capability awareness). Honest and useful. • Partial / degraded—the agent returns an incomplete or low-quality result and, ideally, says so. • Confident-wrong (capability overclaim)—the agent returns a fluent, well-formed, incorrect result and signals no doubt. This is the fault current protocols cannot see. • Drift—the agent’s true reliability changes (typically a backend update) while its advertisement does not. • Misroute—the task reaches an agent whose advertised skill does not match the real need. The first two are observable directly. Refusal and partial results are observable when the agent is built to report them. Confident-wrong is the hard case: it leaves no native signal and surfaces only through screening, a judge, or a post-condition check, which is why it is the fault a trust mechanism must be designed around. This taxonomy scopes the rest of the paper. Crash, timeout, and omission are already handled by ordinary timeouts and retries; refusal and partial results help the caller whenever agents report them honestly. What current protocols cannot see—confident-wrong, the drift that produces it silently, and the misrouting that boolean skill claims invite—is what the Trust Layer of Section 4 is built for: descriptors and screening address confident-wrong and misrouting, while freshness and drift detection address drift. 4 A Trust Layer for Heterogeneous Delegation 4.1 Overview Our design adds a thin layer between a caller and the transport protocol it uses to reach a callee. It does not replace MCP or A2A; it sits above them as a narrow waist, in the sense of the Internet hourglass [Clark 1988]: a minimal common interface that many backends below and many planners above can share. The layer has three parts, each corresponding to one classical remedy for asymmetric information. • Probabilistic capability descriptors let a good provider signal its quality credibly. • Screening lets a caller separate providers by quality before trusting them. • Reputation with drift detection lets the network remember, so that today’s claim is disciplined by yesterday’s results and re-checked when the world changes. Four principles guide the design: it should be agnostic to the model and to the transport; it should be deployable incrementally, working alongside agents that ignore it; and it should respect the end-to-end argument by promising only what a protocol layer can honestly promise. 4.2 Probabilistic capability descriptors (signaling) The descriptor replaces the boolean claim with a structured one. Instead of “I summarize indemnification clauses,” an agent publishes that it does so with reliability approximately 0.91, calibrated on a named benchmark of a stated size and date, with accuracy that falls past roughly eight thousand tokens, produced by backend version v3.2, valid for thirty days. It is, in effect, a nutrition label for competence. The point is not merely richer metadata; it is credible metadata. A bare number is cheap to inflate, so the descriptor’s load-bearing field is provenance: the evidence behind the claim—which evaluation, when, on how many samples. Provenance is what turns the descriptor from cheap talk into a signal in Spence’s sense [Spence 1973], because a claim that points to reproducible evidence is one an overclaimer cannot cheaply imitate. We considered and rejected two extremes: the bare boolean schema of today, which carries no signal, and heavyweight semantic-service ontologies of the 2000s (OWL-S and kin), which demanded so much formality that they were never adopted at scale. The descriptor aims for the smallest schema that can carry a credible signal. 4.3 Screening: challenges and attestation Signals help, but a careful caller will also test. Screening [Rothschild and Stiglitz 1976] is the caller-side complement to provider-side signaling, and it takes two forms here. The first is a challenge, or canary: before entrusting an agent with the real contract, the caller sends a task whose answer it already knows and checks the response. The second is attestation: an independent party evaluates the agent and issues a signed statement of the result, which the agent presents like a credential. Attestation matters because challenges are expensive to design well and wasteful to repeat at every caller; a shared attestation lets one party’s careful evaluation serve many. What screening adds beyond information is cost asymmetry. Passing a real challenge, or earning a genuine attestation, costs more for an agent that lacks the capability than for one that has it. That cost gap is what makes the two types separate rather than pool—the formal point we take up in Section 4.5. 4.3.1 The attestation trust model Attestation invites an obvious and fatal-looking objection: does it not just relocate the trust problem to the attester? If the caller must trust a capability authority, how does anyone know the authority is neutral and has not been bought? Web public-key infrastructure shows the danger is real—certificate authorities have been compromised, and the browser trust-root model failed quietly when they were. We take the objection seriously, and our answer has three moves. First, prefer verifiability over authority. An attestation should not say “trust me, this agent is good.” It should say “I ran this public benchmark with this seed; here is the signed, reproducible transcript.” That turns the attester from a judge into a notary whose work can be re-run or spot-checked. A notary that fabricates results is caught by anyone who reproduces them. The precedent is Certificate Transparency [Laurie et al. 2013], which addressed untrustworthy certificate authorities not by making them honest but by logging their issuances publicly so that misbehavior becomes detectable after the fact. Attestations live in the same kind of append-only log. Second, treat attestation as an optimization, not a foundation. It is one of three screening tools, beside the agent’s own signed descriptor and the caller’s own challenges. Its only job is to amortize evaluation cost across many callers. A caller who trusts no attester does not lose the ability to delegate safely; it falls back to screening agents itself and learning from its own results—slower and costlier, but intact. A corrupt attester therefore does not break the network; it removes an efficiency and reverts the caller to the no-attester baseline. The system degrades gracefully rather than catastrophically, which is a far stronger guarantee than “the authority is honest.” Third, make corruption costly and self-correcting. An attester can post a bond against its attestations, to be slashed to a harmed caller if an audit re-run shows inflation; callers can run several attesters in parallel and weight them; and, decisively, callers compare an attester’s predictions against their own downstream outcomes and discount attesters that systematically overpredict. This recursion bottoms out: an attester is judged, in the end, by real task results the caller observes directly, not by another authority. We do not claim this makes attestation incorruptible. Collusion between a provider and an attester still pays in the short run, before the caller has gathered enough of its own outcomes to notice; re-running evaluations costs money and a transparency log catches fabrication but not subtle bias in test selection; and some capabilities are not cheaply reproducible, in which case attestation reverts toward bare authority and the trust problem genuinely returns. We treat these as scope boundaries (Section 6.5) rather than as solved. 4.4 Reputation and drift (the repeated game) The third remedy is memory. Every real outcome—corroborated by a downstream check, a challenge, or a later contradiction—updates the agent’s reputation, and reputation propagates across the delegation graph in the spirit of EigenTrust [Kamvar et al. 2003], so that an agent vouched for by trusted agents inherits some standing. Memory converts a one-shot bluff into a losing long-run strategy, the familiar discipline of repeated games [Resnick et al. 2000]. Two features are specific to language-model agents. Freshness: descriptors and attestations carry a time-to-live, after which they are discounted or re-checked, so that stale claims do not accrue unearned trust. Drift detection: when a provider changes the backend behind a stable advertisement, the layer treats the version change as an event that expires prior evidence and forces re-validation—directly addressing the “it got worse overnight” failure that no current protocol can notice. Optionally, an agent may stake reputation or budget on a claim, to be slashed on a confirmed confident-wrong result, sharpening the incentive to advertise honestly. 4.5 Why the layer changes the equilibrium The mechanisms are individually familiar; the claim worth making is about their joint effect. We sketch it informally here; Appendix A gives the formal model, the two theorems, and their proofs. Under a faith-based protocol, advertised capability is free and unverified—a cheap-talk setting [Crawford and Sobel 1982]—so a low-reliability provider can mimic a high-reliability one at no cost. No advertisement separates the types, the caller can do no better than treat them alike, and investment in reliability earns no return. The only stable outcome is the pooling equilibrium of Section 3.2—the lemons market. Now add the layer. Signaling attaches a verifiable cost to a credible claim; screening attaches a cost to passing as capable; reputation attaches a future cost to being caught wrong. Write g for the one-shot gain an agent expects from overclaiming and c for the combined cost it must bear to sustain the overclaim through screening and across repeated interactions. When c>gc>g, overclaiming is no longer profitable, honest advertising becomes a best response, and a separating equilibrium exists in which high- and low-reliability providers send distinguishable signals and callers route accordingly. The design’s job is to push c above g—cheaply enough that honest providers will bear it, steeply enough that overclaimers will not. The condition also delimits the design’s reach: where credible challenges cannot be built or identities do not persist, c cannot be raised, and the lemons problem in that corner may be genuinely unsolvable at the protocol layer. 4.6 Composing reliability, and what the layer should promise Because tasks flow down chains, a caller needs to reason not about one hop but about the whole path. If hop k succeeds with probability rkr_k and failures are independent, end-to-end reliability is ∏krk _kr_k, the compounding effect of Section 3.1; where the layer adds a verification step of catch-rate vkv_k at a hop, the residual undetected-error rate falls accordingly, and a caller can bound end-to-end reliability rather than merely hope for it. Independence is an idealization—heterogeneous agents share training data and failure modes—so the bound should be read as a planning tool whose assumptions are stated, not as a guarantee. This is also where the end-to-end argument [Saltzer et al. 1984] disciplines our ambitions. The layer can carry signals, run screening, and keep reputation; it can bound and price reliability and route to improve it. It cannot ensure that a particular answer is semantically correct, because only the endpoints—ultimately the application and its human owners—hold the ground truth. A protocol that promised more would itself be overclaiming. We therefore design the layer to make correctness checkable and accountable rather than guaranteed. 5 Realizing the Trust Layer over MCP and A2A The design is built to fit the protocols that already exist. A descriptor maps onto an A2A agent card as additional fields beside each advertised skill, and onto an MCP tool as annotations beside the tool schema. The added fields are optional and additive: an agent that ignores them still interoperates, and a caller that finds them absent falls back to a default, cautious trust level and to its own screening. A small gateway can sit in front of a heterogeneous fleet, speak each transport, and normalize claims into the common descriptor form—the narrow waist in practice. Attestations and reputation records are published to an append-only log addressed by agent identity, so that any caller can fetch an agent’s history without a central clearinghouse mediating each lookup. None of this requires changing a model; it changes only what travels alongside the call. We leave a reference schema and validator to future work. 6 Analysis We report no measurements of a live system, and we will not dress the analysis up as one. What we offer is threefold: the equilibrium results of Appendix A; an illustrative agent-based simulation that visualizes those results (Section 6.3); and grounding in reliability measurements others have already published. The simulation is a closed world—no language model is queried, every provider’s reliability is a stipulated parameter, and the correctness oracle is assumed—so it can show only that the mechanism behaves as the proofs say, never that the magnitudes match any real deployment. Building and measuring such a deployment is the natural next step and is out of scope here. 6.1 Setup The arguments below assume the system model of Section 2: an open network, repeated interactions, persistent identities, and the existence of at least some tasks whose answers can be checked. Where those assumptions fail, the conclusions weaken in ways we flag. 6.2 Research questions • RQ1. Does a faith-based protocol collapse to a low-trust equilibrium? We argue yes (Section 3.2, Theorem 1): with free, unverified advertisement, no signal separates the types and pooling is the only stable outcome. The simulation (Figure 1) shows the collapse directly. • RQ2. Does the Trust Layer admit a separating equilibrium, and at what cost? We argue yes when c>gc>g (Theorem 2): when the cost of sustaining an overclaim exceeds its gain, honest advertising is a best response. The simulation locates the transition precisely at c=gc=g (Figure 2). • RQ3. How does reliability scale with chain depth, with and without the layer? The composition of Section 4.6 makes the dependence explicit—naive chains decay multiplicatively, while a verification step at each hop curbs the decay—so the layer’s value grows with depth (Figure 3). • RQ4. Is confident-wrong prevalent enough to matter? Published benchmarks say yes. Holistic evaluations report wide reliability spreads across model families [Liang et al. 2022], agent benchmarks show large gaps on multi-step tasks [Liu et al. 2023], and tool-use studies document frequent, confidently-made errors [Qin et al. 2023]. The fault we target is the common case, not a corner case. • RQ5. What does screening cost? In the worst case, one extra challenge call per new provider-task pairing; attestation amortizes this across callers, and reputation lets a caller skip screening for providers it already trusts, so steady-state overhead falls well below the first-encounter cost. 6.3 An illustrative simulation To make the equilibrium results tangible we built a small agent-based simulation (a few hundred lines of Python, available at https://github.com/grvnmttl/lemons-market-sim). A population of providers each choose whether to invest in genuine reliability—at an idiosyncratic cost κi _i—and what to advertise, then revise by myopic best response over many rounds, under two regimes (faith-based and Trust Layer), averaged over 24 random seeds. The parameters are stylized: low and high true reliabilities rL=0.55r_L=0.55 and rH=0.92r_H=0.92, so the overclaim gain is g=0.37g=0.37. As stressed in the setup, this illustrates Appendix A; it does not test the design against reality. Figure 1 shows the central contrast (RQ1, RQ2). Both regimes begin from a healthy market in which half the providers have invested. Under faith-based advertising the market unravels within a few rounds: realized reliability falls to rLr_L and the share investing in genuine reliability collapses to near zero—the lemons outcome of Theorem 1 and Corollary 1.1. Under the Trust Layer with c=1.5gc=1.5\,g, reliability holds near rHr_H and the invested share settles at 0.580.58, essentially the predicted P(κ<g−cH)=0.583P(κ<g-c_H)=0.583 of Corollary 2.1. Figure 1: Faith-based advertising versus the Trust Layer over time (mean of 24 seeds; bands are ±1± 1 s.d.). (a) The realized reliability obtained by a caller collapses to rLr_L under faith-based advertising but holds near rHr_H under the layer. (b) The share of providers investing in genuine reliability falls to near zero under faith-based advertising (Corollary 1.1) and settles at the predicted P(κ<g−cH)P(κ<g-c_H) under the layer (Corollary 2.1). Figure 2 sweeps the screening cost (RQ2). As c crosses g the steady state flips sharply: overclaiming falls from a majority of providers to near zero, and market reliability jumps from about 0.650.65 to rHr_H. The transition sits exactly at c=gc=g, as Theorem 2 requires. Figure 2: Steady-state outcomes as the screening cost c varies relative to the overclaim gain g. Separation appears precisely at c=gc=g (Theorem 2): overclaiming collapses and market reliability jumps to rHr_H. Figure 3 composes per-hop reliability into delegation chains (RQ3). Because reliability multiplies along a chain, the faith-based market—reliable only about 0.550.55 per hop—is correct barely 5% of the time at depth five, whereas the Trust Layer with per-hop verification stays above 0.80.8. The layer’s advantage widens with depth, which is the direction real agent networks are heading. Figure 3: End-to-end reliability versus delegation-chain depth, using each regime’s steady-state per-hop reliability. Multiplicative decay punishes the faith-based market severely; the Trust Layer with per-hop verification (catch-rate v=0.5v=0.5) degrades far more gently. 6.4 Ablation Remove descriptors and providers cannot signal, so screening must carry the entire burden and the per-call cost rises. Remove screening and signals revert to cheap talk, collapsing toward pooling. Remove reputation and each interaction stands alone, so drift goes unnoticed and a provider can overclaim afresh against every new caller. Each part earns its place by guarding a failure the others do not. 6.5 Limitations and failure modes Several boundaries deserve to be stated plainly. Calibration bootstrapping: a provider’s self-reported reliability is only as good as the evaluation behind it, and a provider cannot fully self-assess; the design leans on external evidence precisely because of this, but cold-start cases have little evidence to lean on. Attestation under collusion: as Section 4.3.1 concedes, a captured attester pays off in the short run, and verifiability catches fabrication but not biased test selection. Correlated errors: heterogeneous agents are not independent, so cross-checking and voting are weaker than the arithmetic suggests, and the composition bound should be read with that caveat. Reputation gaming and fairness: Sybil identities, collusive vouching, and incumbency advantage are real, and a reputation system can entrench early movers; mitigations exist but none is complete. Non-reproducible capabilities: where outputs are stochastic or test sets are private, screening and attestation lose force and the trust problem returns in full. Closed-world simulation: the Section 6.3 simulation illustrates only the model’s own dynamics; its magnitudes are artifacts of stipulated parameters and carry no empirical weight about real systems. 7 Related Work Agent protocols. MCP [Anthropic 2024] and A2A [Google 2025], along with function-calling interfaces and frameworks such as AutoGen and LangGraph, define how agents advertise and invoke capabilities. They are the substrate this work builds on, and the capability-and-trust gap they leave is the gap we fill; we add a layer above them rather than competing with them. Trust and verification for LLM agents. Trust in LLM-agent systems has become an active research area. Surveys now catalog threats and countermeasures across single- and multi-agent settings [Yu et al. 2025], and several systems attach per-agent credibility or reputation scores so that agents can discount unreliable peers [Ebrahimi et al. 2025]. Security analyses of MCP document semi-honest servers that obey the wire protocol while behaving differently from what they advertise [Hou et al. 2025]—the adversarial counterpart of the confident-wrong fault we study. The verification tools these systems lean on, LLM-as-judge foremost among them, are themselves of uneven reliability [Gu et al. 2024]. We differ from this work in what we provide more than in what we observe. Where it treats untrustworthiness as a security threat, or supplies a trust score whose guarantees stay implicit, we give an economic account: capability advertisement is a market for lemons, which is why the problem is structural rather than incidental, and why a mechanism helps only once screening costs more than overclaiming gains (Section 4.5). Our overclaiming is also non-adversarial—a faithful report of a wrong self-belief—so it survives among the cooperative agents that a security framing assumes away. And we site the remedy in a protocol-layer narrow waist above MCP and A2A, not inside one framework. Classical multi-agent systems. The problem of one agent delegating to another is old. The Contract Net Protocol [Smith 1980] formalized task announcement and bidding; FIPA standardized agent communication languages; the belief–desire–intention model [Rao and Georgeff 1995] and platforms like JADE [Bellifemine et al. 2007] built on these. That tradition largely assumed cooperative agents whose advertised competence was truthful and stable. Our departure is to drop that assumption: when competence is probabilistic and self-reported by a language model, the classical machinery has no account of overclaiming, and that is precisely what the Trust Layer supplies. Trust and reputation. Reputation systems for online marketplaces and peer-to-peer networks [Resnick et al. 2000, Kamvar et al. 2003] inform our reputation sublayer. We build on them, adding freshness and drift detection for the specific problem of a backend that changes beneath a stable advertisement. Economics of asymmetric information. The market for lemons [Akerlof 1970] is our framing, and signaling [Spence 1973] and screening [Rothschild and Stiglitz 1976] are the remedies we operationalize. The contribution is to recognize that capability advertisement is a lemons market and that these remedies map onto concrete protocol mechanisms. Distributed systems. We draw on Byzantine fault tolerance [Lamport et al. 1982] and the dependability taxonomy [Avizienis et al. 2004] to position confident-wrong as a distinct fault, on the end-to-end argument [Saltzer et al. 1984] to decide what the layer should promise, and on the narrow-waist design of the Internet [Clark 1988] for the deployment story. LLM evaluation. Holistic and agentic benchmarks [Liang et al. 2022, Liu et al. 2023, Qin et al. 2023] supply the empirical grounding that confident-wrong is prevalent, and model cards [Mitchell et al. 2019] are the documentation lineage our descriptors extend toward machine-readable, probabilistic claims. 8 Discussion If capability advertisements become credible, a market can form around them. Reliability could be priced, attesters could compete on the rigor of their evaluations, and agents could be selected on demonstrated competence rather than on fluent self-description. That is the optimistic reading, and it is worth pursuing, but it carries its own hazards: attestation can centralize, reputation can entrench incumbents, and a market that prices reliability can also be gamed by those who learn to look reliable. The framing generalizes beyond language models. Any open network of services with hidden quality and cheap claims has a lemons problem, and the same triad—signal, screen, remember—applies. The specifics that make our setting distinctive are that quality is probabilistic and context-dependent rather than binary, and that it drifts on a timescale short enough to matter. Several problems remain open. Cross-checking under correlated, heterogeneous errors is genuinely unsolved and may deserve its own treatment. Decentralizing attestation without recreating a trusted root is hard. And bootstrapping calibration where no evaluation history exists is a chicken-and-egg problem the design mitigates but does not dissolve. We see these as the agenda this framing opens, not as gaps that undermine it. 9 Conclusion Today’s agent protocols assume that an agent’s advertised capability is true, static, and known. Language-model agents violate all three, and the failures they produce have a single economic root: a market for lemons, in which honest reliability cannot distinguish itself and the network drifts toward confident overclaimers. Seen this way, the remedies are the ones economics has long known—signaling, screening, and reputation—none of which today’s protocols provide. We have proposed the Trust Layer, a thin and protocol-agnostic narrow waist that supplies exactly these three mechanisms above MCP and A2A, and we have argued that it turns a pooling equilibrium of lemons into a separating equilibrium in which reliability is provable and rewarded, whenever the cost of sustaining an overclaim can be pushed above its gain. The design needs no retraining, deploys incrementally, and—because its attestation anchor is an optimization rather than a foundation—degrades gracefully when trust is scarce. The most pressing next step is to build it and measure it: to learn, in a live heterogeneous network, how high that cost must be set, and where the corners are in which the lemons cannot be cleared at all. Appendix A Equilibrium Analysis This appendix formalizes the claim of Section 4.5: a faith-based protocol admits only a pooling (low-trust) equilibrium, whereas the Trust Layer’s screening admits a separating equilibrium exactly when the cost of sustaining an overclaim exceeds the gain from it. The model is a standard signaling game in the lineage of Akerlof, Spence, and Stiglitz. What is new is the mapping: casting capability advertisement as a lemons market turns a vague worry about untrustworthy agents into two precise claims—that trust collapses without a mechanism (Theorem 1), and that a mechanism restores it once screening costs more than overclaiming gains (Theorem 2). A.1 Model There is a population of providers and a population of callers. Each provider has a hidden type θ∈L,Hθ∈\L,H\ with true task-success probabilities rL<rHr_L<r_H in [0,1][0,1]. A fraction λ∈(0,1)λ∈(0,1) of providers are type H; write the prior-mean reliability as ρpool=λrH+(1−λ)rL. _pool\;=\;λ\,r_H+(1-λ)\,r_L. A provider observes its own type and publishes an advertisement (a message) m∈Mm∈ M. A caller observes m—and, where a screening technology exists, a verifiable credential—forms a posterior belief, and decides whom to delegate to and what to pay. We summarize the caller side by a single trust price B(ρ)B(ρ): the benefit a provider receives when callers perceive its success probability to be ρ (more work routed to it, a higher fee, or both). We assume: • (A1) Monotone trust price. B is strictly increasing in ρ. Write BH=B(rH)B_H=B(r_H), BL=B(rL)B_L=B(r_L), Bpool=B(ρpool)B_pool=B( _pool), so BL<Bpool<BHB_L<B_pool<B_H. • (A2) Two types. rL<rHr_L<r_H. (The continuum case is Remark A.5.3.) • (A3) Cheap talk under faith-based advertising. Messages are costless and type-independent: any type can send any m∈Mm∈ M at zero cost, and there is no verification. • (A4) Single-crossing screening. A screening technology lets a provider obtain a high credential. Obtaining it costs cH≥0c_H≥ 0 for a true H and cH+c_H+c for a true L, with c>0c>0. That is, faking competence on a genuine challenge is strictly costlier than demonstrating it. (This is the Spence–Mirrlees single-crossing property [Spence 1973, Mirrlees 1971]; it presumes verifiable task instances exist.) • (A5) Rational play. Providers are risk-neutral and maximize trust price minus cost; callers are Bayesian and the trust price they pay is increasing in their posterior (by A1). Define the recognition premium, equivalently the one-shot overclaim gain, g:=BH−BL> 0.g\;:=\;B_H-B_L\;>\;0. This is what a type L would capture by passing itself off as H. A.2 Equilibrium concepts The solution concept is Perfect Bayesian Equilibrium (PBE): a strategy profile and a belief system such that strategies are sequentially rational given beliefs, and beliefs are derived from strategies by Bayes’ rule on the equilibrium path. An equilibrium is separating if distinct types induce distinct posteriors (the caller can tell them apart) and pooling if all participating types induce the same posterior (the caller cannot). Where multiple PBE exist we invoke the Cho–Kreps Intuitive Criterion [Cho and Kreps 1987] as a refinement (Remark A.5.1). A.3 Faith-based advertising collapses to pooling Theorem 1. Under faith-based advertising (A3), no separating PBE exists. Every PBE is outcome-equivalent to a pooling equilibrium in which advertising is uninformative and the perceived reliability of every participating provider equals the population mean ρpool _pool. Proof. (No separation.) Suppose, for contradiction, an informative PBE in which two messages induce different posteriors. Let m¯ m be an on-path message inducing the highest posterior reliability ρ¯ ρ, and let m¯ m be an on-path message inducing a strictly lower posterior ρ¯<ρ¯ ρ< ρ, sent by some type t. Beliefs attach to the message, not to the sender’s identity, so any provider sending m¯ m is perceived as ρ¯ ρ. Consider type t: its equilibrium payoff is B(ρ¯)B( ρ), while deviating to m¯ m yields B(ρ¯)−0>B(ρ¯)B( ρ)-0>B( ρ) by (A1) and the costlessness of messages (A3). The deviation is strictly profitable, contradicting equilibrium. Hence all participating types induce a single posterior. (Value of the pool.) With one on-path posterior and all types participating, Bayes’ rule gives P(H∣m)=λP(H m)=λ, so the perceived reliability is λrH+(1−λ)rL=ρpoolλ r_H+(1-λ)r_L= _pool. ∎ The economic content is that without verification a low type can always mimic a high type’s words at no cost, so words carry no information and trust defaults to the average—the market for lemons. Theorem 1 is the costless-message (cheap-talk) special case in the lineage of Crawford and Sobel [Crawford and Sobel 1982]. Corollary 1.1 (Investment collapse). Add a prior stage in which a provider may pay κ>0κ>0 to become type H (otherwise it is L), with reliability rewarded only through perception. Under faith-based advertising, no provider invests; the equilibrium fraction of high types is λ=0λ=0 and realized reliability converges to rLr_L. Proof. A single provider is of negligible mass and, by Theorem 1, cannot signal its type, so its perceived reliability is ρpool _pool whether or not it invests. Its gross benefit is thus B(ρpool)B( _pool) either way, while investing additionally costs κ>0κ>0. Not investing strictly dominates, so no one invests and the realized population is all L. ∎ This is the unraveling: because reliability cannot be demonstrated, paying to be reliable is strictly irrational, and the network decays to its weakest type. Corollary 1.1 drives the collapse through the investment margin. The same force also operates on a participation margin—high types exiting the market rather than accept a pooled price—which we make explicit so that no exit channel is left unmodelled. Proposition 1.2 (Participation and unraveling). Suppose each type θ has an outside option worth uθu_θ, with uL≤uHu_L≤ u_H, and participates only if its market payoff is at least uθu_θ. Under faith-based advertising: (i) if B(ρpool)≥uHB( _pool)≥ u_H, full participation is sustained and the market pools at ρpool _pool; (i) if B(ρpool)<uHB( _pool)<u_H, the high type exits, the surviving market contains only low types and is perceived at rLr_L, and it trades iff B(rL)≥uLB(r_L)≥ u_L. Proof. By Theorem 1 any set of participants pools at the mean reliability of that set, and each participant earns the corresponding trust price. (i) If both types participate the perceived value is ρpool _pool and each earns B(ρpool)B( _pool); the high type’s participation constraint B(ρpool)≥uHB( _pool)≥ u_H holds by assumption, and the low type’s holds a fortiori since uL≤uHu_L≤ u_H and ρpool≥rL _pool≥ r_L. (i) If B(ρpool)<uHB( _pool)<u_H the high type’s participation constraint fails under full participation, so it exits; with only low types remaining the pooled mean is rLr_L, giving each survivor B(rL)B(r_L), and the low type stays iff B(rL)≥uLB(r_L)≥ u_L. ∎ With two types the exit is a single step; with a continuum of qualities it cascades, since each marginal exit lowers the participant mean and can trigger the next, so the market can unravel all the way to the lowest type—Akerlof’s original result. Either way, the high-quality end of an unverified agent market is driven out, whether by withdrawing effort (Corollary 1.1) or by withdrawing entirely (Proposition 1.2). A.4 Screening restores separation Theorem 2. Add the single-crossing screening technology (A4) with a binary credential. A separating PBE exists if and only if cH≤gandc>g−cH,c_H≤ g c\;>\;g-c_H, and whenever it exists it is unique in form: the true-H providers obtain the credential and are perceived as H (ρ=rHρ=r_H), while L providers do not and are perceived as L (ρ=rLρ=r_L). In the normalized case cH=0c_H=0 the condition reduces to c>gc>g: separation is sustainable exactly when the cost of sustaining an overclaim exceeds the gain from it. Proof. Consider the candidate profile: type H obtains the credential and is perceived as rHr_H; type L does not and is perceived as rLr_L; off the path, any provider lacking the credential is believed to be L. We check sequential rationality. Type L (incentive not to mimic). Honesty yields BLB_L (perceived L, no screening cost). Mimicking —obtaining the credential—yields BH−(cH+c)B_H-(c_H+c). Type L prefers honesty iff BL≥BH−cH−c⟺c≥(BH−BL)−cH=g−cH,B_L\;≥\;B_H-c_H-c\; \;c\;≥\;(B_H-B_L)-c_H\;=\;g-c_H, with strict preference iff c>g−cHc>g-c_H. (IC-L) Type H (incentive to screen). Screening yields BH−cHB_H-c_H; abstaining yields BLB_L (perceived L). Type H screens iff BH−cH≥BL⟺cH≤g.(IC-H)B_H-c_H\;≥\;B_L\; \;c_H\;≤\;g. (IC-H) Caller. On the path, the credential is held only by H, so the posterior rHr_H given a credential and rLr_L otherwise is Bayes-consistent; paying a trust price increasing in the posterior is optimal by (A5). Both incentive constraints hold precisely when cH≤gc_H≤ g and c>g−cHc>g-c_H, so the profile is a PBE. This proves sufficiency. Necessity and uniqueness. Consider any separating PBE. Cheap-talk messages cannot separate types (the argument of Theorem 1), so separation must ride on the credential—the only verifiable instrument—and exactly one type holds it, the holder perceived rHr_H and the non-holder rLr_L. The holder must be the high type: if instead L held the credential and H did not, then H—perceived rLr_L—could acquire it at cost cHc_H to be perceived rHr_H, a change of g−cHg-c_H; moreover for L to hold it at all requires BH−cH−c≥BLB_H-c_H-c≥ B_L, i.e. c≤g−cHc≤ g-c_H, which combined with c>0c>0 forces cH<gc_H<g and hence g−cH>0g-c_H>0, so H’s deviation is strictly profitable and breaks the candidate. Thus any separating PBE has H holding and L not. Given that profile, L’s incentive not to mimic requires BL≥BH−(cH+c)B_L≥ B_H-(c_H+c), i.e. c≥g−cHc≥ g-c_H (strict for strict incentives), and H’s incentive to hold rather than pool down requires BH−cH≥BLB_H-c_H≥ B_L, i.e. cH≤gc_H≤ g. Both conditions are therefore necessary for any separating PBE, not merely for the constructed one, and they are sufficient by the construction above. Hence they characterize separation as such, and the separating profile is unique. Setting cH=0c_H=0 gives c>gc>g. ∎ Corollary 2.1 (Investment restored). With screening and separation, in the prior investment stage a provider invests to become H iff κ≤g−cHκ≤ g-c_H. For investment cheap relative to the recognition premium, providers invest and equilibrium reliability rises toward rHr_H. Proof. Investing yields the separating high payoff net of screening, BH−cHB_H-c_H; not investing yields BLB_L. Investing is optimal iff BH−cH−κ≥BLB_H-c_H-κ≥ B_L, i.e. κ≤g−cHκ≤ g-c_H. ∎ Theorems 1 and 2 together are the formal version of the paper’s thesis: the same network that collapses to lemons under faith-based advertising (Theorem 1, Corollary 1.1) separates and rewards genuine reliability once screening makes overclaiming cost more than it pays (Theorem 2, Corollary 2.1). A.5 Remarks A.5.1 (Equilibrium selection.) The screening game also admits pooling PBE sustained by pessimistic off-path beliefs. When c>g−cHc>g-c_H holds, the separating equilibrium is the unique outcome surviving the Cho–Kreps Intuitive Criterion: from any pooling candidate, a true H has a deviation—obtain the credential—that is profitable for H but not for L, so the caller should attribute it to H, which unravels the pool. This is the standard Spence/Riley selection [Cho and Kreps 1987, Riley 1979]; we invoke it to justify focusing on separation. A.5.2 (Reputation as the source of c.) In a one-shot game, c is the direct screening-plus-penalty cost of obtaining the credential. In the repeated setting of Section 4.4, being caught confident-wrong forfeits future recognition: with discount factor δ, per-period premium g, and per-period detection probability p, the present value an overclaimer loses upon eventual detection is on the order of δ1−δpg δ1-δ\,p\,g. Reputation therefore adds to the effective c, and a sufficiently patient market (high δ) with non-trivial detection (p>0p>0) pushes c above g endogenously. This connects the static condition c>gc>g to the repeated-game mechanism and explains why reputation and screening are complements, not alternatives. A.5.3 (Continuum of types.) Replacing L,H\L,H\ with a continuum r∈[rmin,rmax]r∈[r_ ,r_ ] and retaining single-crossing yields the least-cost (Riley) separating equilibrium, in which the credential intensity rises monotonically with true reliability and the same incentive logic binds locally. We use two types only for transparency. A.5.4 (Assumptions and scope.) The results require: a screening technology with single-crossing (A4)—i.e., verifiable task instances on which a true H succeeds more cheaply than an L; this fails where capabilities are non-reproducible (Section 6.5). Reputation’s contribution to c (A.5.2) requires persistent identities (Sections 2 and 6.5). And (A1, A5) assume risk-neutral providers facing a trust price monotone in perceived reliability. Where these hold, separation is achievable; where they fail—unverifiable tasks, disposable identities—c cannot be raised above g and the lemons problem may be irreducible at the protocol layer, as Section 4.5 notes. A.6 The reliability-composition bound (Section 4.6) For a delegation chain of depth n with per-hop success probabilities r1,…,rnr_1,…,r_n and independent failures, end-to-end success is ∏k=1nrk _k=1^nr_k. If the layer adds a verification step at hop k that catches a fraction vk∈[0,1]v_k∈[0,1] of that hop’s errors, the hop’s effective failure probability falls to (1−rk)(1−vk)(1-r_k)(1-v_k), so its effective success probability is rk′= 1−(1−rk)(1−vk)≥rk,r_k \;=\;1-(1-r_k)(1-v_k)\;≥\;r_k, and end-to-end success is ∏krk′≥∏krk _kr_k ≥ _kr_k: verification helps more as the chain deepens. Independence is an idealization (Section 4.6). Without it, a conservative planning bound follows from Boole’s inequality—end-to-end failure probability ≤∑k(1−rk′)≤ _k(1-r_k )—which the layer can compute from per-hop descriptors without assuming independence. Either way this is a bound and a planning tool, not a correctness guarantee: by the end-to-end argument, semantic correctness remains with the endpoints. References [Akerlof 1970] Akerlof, G. A. (1970). The Market for “Lemons”: Quality Uncertainty and the Market Mechanism. Quarterly Journal of Economics, 84(3), 488–500. [Anthropic 2024] Anthropic (2024). Introducing the Model Context Protocol. November 2024. https://modelcontextprotocol.io. [Avizienis et al. 2004] Avizienis, A., Laprie, J.-C., Randell, B., Landwehr, C. (2004). Basic Concepts and Taxonomy of Dependable and Secure Computing. IEEE Transactions on Dependable and Secure Computing, 1(1), 11–33. [Bellifemine et al. 2007] Bellifemine, F., Caire, G., Greenwood, D. (2007). Developing Multi-Agent Systems with JADE. Wiley. [Cho and Kreps 1987] Cho, I.-K., Kreps, D. (1987). Signaling Games and Stable Equilibria. Quarterly Journal of Economics, 102(2), 179–221. [Clark 1988] Clark, D. (1988). The Design Philosophy of the DARPA Internet Protocols. ACM SIGCOMM, 109–114. [Crawford and Sobel 1982] Crawford, V. P., Sobel, J. (1982). Strategic Information Transmission. Econometrica, 50(6), 1431–1451. [Ebrahimi et al. 2025] Ebrahimi, S., et al. (2025). An Adversary-Resistant Multi-Agent LLM System via Credibility Scoring. arXiv:2505.24239. [Google 2025] Google (2025). Announcing the Agent2Agent (A2A) Protocol. Google Developers Blog, April 2025. https://github.com/a2aproject/A2A. [Gu et al. 2024] Gu, J., et al. (2024). A Survey on LLM-as-a-Judge. arXiv:2411.15594. [Hou et al. 2025] Hou, X., Zhao, Y., Wang, S., Wang, H. (2025). Model Context Protocol (MCP): Landscape, Security Threats, and Future Research Directions. arXiv:2503.23278. [Kamvar et al. 2003] Kamvar, S., Schlosser, M., Garcia-Molina, H. (2003). The EigenTrust Algorithm for Reputation Management in P2P Networks. In Proc. 12th International Conference on World Wide Web (W), 640–651. [Lamport et al. 1982] Lamport, L., Shostak, R., Pease, M. (1982). The Byzantine Generals Problem. ACM Transactions on Programming Languages and Systems, 4(3), 382–401. [Laurie et al. 2013] Laurie, B., Langley, A., Kasper, E. (2013). Certificate Transparency. RFC 6962. [Liang et al. 2022] Liang, P., et al. (2022). Holistic Evaluation of Language Models (HELM). arXiv:2211.09110; published in Transactions on Machine Learning Research (2023). [Liu et al. 2023] Liu, X., et al. (2023). AgentBench: Evaluating LLMs as Agents. arXiv:2308.03688; ICLR 2024. [Mirrlees 1971] Mirrlees, J. A. (1971). An Exploration in the Theory of Optimum Income Taxation. Review of Economic Studies, 38(2), 175–208. [Mitchell et al. 2019] Mitchell, M., et al. (2019). Model Cards for Model Reporting. In Proc. Conference on Fairness, Accountability, and Transparency (FAT*). (The conference was renamed FAccT in 2020.) [Qin et al. 2023] Qin, Y., et al. (2023). ToolLLM: Facilitating Large Language Models to Master 16000+ Real-World APIs. arXiv:2307.16789; ICLR 2024. [Rao and Georgeff 1995] Rao, A., Georgeff, M. (1995). BDI Agents: From Theory to Practice. In Proc. First International Conference on Multiagent Systems (ICMAS), AAAI Press, 312–319. [Resnick et al. 2000] Resnick, P., Kuwabara, K., Zeckhauser, R., Friedman, E. (2000). Reputation Systems. Communications of the ACM, 43(12), 45–48. [Riley 1979] Riley, J. (1979). Informational Equilibrium. Econometrica, 47(2), 331–359. [Rothschild and Stiglitz 1976] Rothschild, M., Stiglitz, J. (1976). Equilibrium in Competitive Insurance Markets: An Essay on the Economics of Imperfect Information. Quarterly Journal of Economics, 90(4), 629–649. [Saltzer et al. 1984] Saltzer, J., Reed, D., Clark, D. (1984). End-to-End Arguments in System Design. ACM Transactions on Computer Systems, 2(4), 277–288. [Smith 1980] Smith, R. G. (1980). The Contract Net Protocol: High-Level Communication and Control in a Distributed Problem Solver. IEEE Transactions on Computers, C-29(12), 1104–1113. [Spence 1973] Spence, M. (1973). Job Market Signaling. Quarterly Journal of Economics, 87(3), 355–374. [Yu et al. 2025] Yu, M., et al. (2025). A Survey on Trustworthy LLM Agents: Threats and Countermeasures. arXiv:2503.09648.

Instant research discovery