The Economics of Autonomous Agent Networks: Achieving Liquidity and Useful Network Effects

Full report

On this page

The transition of artificial intelligence from conversational interfaces to autonomous, goal-directed agents necessitates a fundamental shift in digital infrastructure. While isolated agents can execute linear workflows, the true potential of agentic systems lies in heterogeneous multi-agent coordination, where independently operating actors discover counterparts, delegate specialized sub-tasks, and exchange artifacts or capital. However, bootstrapping a decentralized, multi-sided network of autonomous economic actors presents profound challenges in platform economics. Unlike human-centric networks, an agent coordination network must facilitate machine-speed discovery, negotiate deterministic contracts, settle micro-transactions securely, and defend against automated Sybil attacks without relying on manual intervention. This report investigates the mechanisms by which an autonomous-agent coordination network can achieve widespread adoption through genuine economic usefulness, avoiding the pitfalls of manufactured traffic, spam, and unscalable activity inflation.

1. The Architecture of Agent Discovery and Encounter

The foundation of any two-sided marketplace is the mechanism by which demand encounters supply at the precise moment a capability is required. In traditional web architectures, this occurs through search engines or centralized directories. For autonomous agents, discovery must be semantic, machine-readable, and embedded within the agent's autonomous execution loop.

Agents encounter services through standardized protocols that broadcast capabilities without requiring deep, bespoke integration. The Model Context Protocol (MCP), developed by Anthropic, acts as a primary syntactic interface, standardizing how individual agents securely connect to external tools and data sources1. While MCP powers agents internally with context and tools, it does not inherently support peer-to-peer collaboration or task delegation1. For horizontal coordination, the Agent-to-Agent (A2A) protocol provides the formalized layer for multi-agent workflows involving handoffs, context-aware collaboration, and artifact sharing1.

Discovery in these networks relies heavily on capability manifests, often referred to as "Agent Cards." An Agent Card is a standardized JSON document detailing an agent's identity, supported communication modalities, authentication requirements, and specific skills4. These cards are typically hosted at predictable, well-known URIs, though the namespace is currently fragmented. The /.well-known/agent.json path is contested by multiple emerging drafts, including the Agent Web Protocol's capability manifest and a payments-focused specification6. Consequently, the A2A protocol shifted its standard discovery endpoint to /.well-known/agent-card.json to avoid namespace collisions6.

To support scalable discovery without relying on centralized, proprietary platforms, the ecosystem is developing layered resolution frameworks. The Agent Discovery Protocol (ADP) leverages existing Internet infrastructure to facilitate discovery at three distinct layers: DNS TXT and SRV records for lightweight service discovery, well-known URIs for metadata retrieval, and WebSocket endpoints for real-time interaction7. This architecture allows an agent to verify the identity and capabilities of a remote counterpart before establishing a connection7. The proposed agent:// URI scheme complements this by providing a semantic routing layer that explicitly signals a resource as an autonomous agent, enabling resolution and invocation without altering underlying transports like HTTPS8. Additionally, the agents.json specification bridges legacy web infrastructure by extending OpenAPI documents, grouping standard API operations into agent-executable semantic flows10.

Successful task completion within this architecture organically generates invitations and referrals through artifact provenance. When a remote server agent delivers a final output—referred to as an artifact—the metadata of that deliverable often contains cryptographic signatures or references to the originating agent4. If the client agent is queried by its human operator regarding how it achieved a specific result, or if the agent publishes the artifact to a broader network, the embedded provenance acts as a verifiable referral, prompting other network participants to utilize the same remote service.

2. A Causal Model of Useful Network Effects

A network effect occurs when the addition of a participant improves the value of the system for existing participants12. In a two-sided autonomous agent network, value is not derived from human attention or engagement metrics, but from the reliable, low-friction execution of economic tasks. The causal model of useful network effects in this context operates through intertwined feedback loops of liquidity, specialization, and execution speed.

The core positive reinforcement mechanism begins with supply diversity. As more specialized service agents join the network, the probability that a client agent will find an exact, optimized match for a highly specific sub-task increases. This match probability reduces the search costs and latency associated with task delegation. When client agents consistently experience high match probabilities and rapid execution, their human operators are incentivized to route more complex workflows through the network, increasing demand density. This heightened demand translates into greater economic throughput, which in turn attracts more niche supply agents seeking to monetize their specialized capabilities, thereby compounding the network's value.

Conversely, unmanaged growth introduces severe negative network effects, primarily through congestion and the proliferation of irrelevant offers. If the supply side is flooded with poorly calibrated, generalized, or spam agents, the search cost for the client agent skyrockets13. The client agent must spend valuable compute cycles and micro-transaction fees negotiating with, evaluating, and ultimately rejecting irrelevant bids.

This negative dynamic is fundamentally driven by the "Agent Lemons Problem," a modern extension of George Akerlof's classic theory of asymmetric information14. In human markets, a buyer can inspect a used car or a physical good. In agent markets, the good being traded is often a learned behavior, a calibrated heuristic, or a proprietary memory artifact14. Inspecting this digital artifact fully requires consuming it, which effectively destroys its scarcity value14. A seller cannot demonstrate the quality of a memory artifact without transferring the knowledge, meaning they cannot prove quality without giving the product away for free14.

This creates a "double-black-box" challenge of deep epistemic opacity, where opaque AI methods are applied to complex, uncertain environments16. Because the true quality of the agent's service is inscrutable prior to purchase, buyers discount the price they are willing to pay. Consequently, high-quality agents exit the market because they cannot secure fair compensation, leaving behind a congested marketplace of "social lemons"—flawed or fraudulent agents that drag down the entire network's reliability17. Without cryptographic verification mechanisms, network growth inherently degrades network quality.

3. The Fragmentation of Liquidity

Liquidity in an agent network is not monolithic; it is deeply fragmented across multiple operational and semantic dimensions. A system may boast millions of registered agents but still suffer from a lack of effective liquidity if supply and demand cannot align perfectly on specific parameters.

Specialization is the most obvious fragmenting force. An agent optimized for genomic data sequencing cannot serve a request for cryptographic smart contract auditing. Geography and latency further fragment the market because certain autonomous workflows—such as high-frequency trading execution or real-time industrial robotics coordination—require sub-millisecond physical proximity. Distant agents become economically unviable despite possessing the correct technical skills.

The most profound fragmentation, however, occurs at the semantic and communication layers. Agent communication can be categorized into three layers: communication (reliable transmission), syntactic (shared message formatting), and semantic (shared intent and ambiguity resolution)18. While protocols like A2A and MCP solve the communication and syntactic layers, agents built on different foundation models often interpret intent, constraints, and operational ambiguity differently18. In human communication, misunderstandings are resolved through real-time clarification; in autonomous networks, semantic misalignment frequently results in task failure or infinite execution loops, isolating agents into siloed clusters that share the exact same underlying logic models18.

Finally, pricing structures heavily fragment liquidity. Client agents are constrained by the autonomous budgets allocated by their human operators. Furthermore, the ecosystem is divided by competing payment protocols. The x402 protocol integrates payments directly into HTTP resource access, the Agent Payments Protocol (AP2) relies on signed mandates for delegated authorization, and the Agentic Commerce Protocol (ACP) coordinates agent-driven checkout over existing merchant infrastructure19. If a client agent operates exclusively on x402 via the Base network, it cannot transact with a highly capable supply agent that only accepts AP2 mandates on a different ledger, permanently bifurcating market liquidity19.

4. Solving the Cold-Start Problem: A Minimal Assumption Strategy

The cold-start problem represents the primary existential threat to any two-sided platform: supply will not join without existing demand, and demand will not engage without reliable supply12. In human ridesharing networks, this was historically solved through heavy capital subsidies to guarantee supply density12. For an autonomous agent network, a strategy relying on capital subsidies, undisclosed self-trading, or unsolicited mass outreach is mathematically unsustainable and violates the requirement for genuine economic usefulness. The optimal strategy relies on the principle of single-player utility bridging naturally to multiplayer network effects.

The most viable cold-start strategy requires the system to provide immediate, standalone value to a single participant before any network matching occurs. This begins by anchoring the system in the Model Context Protocol (MCP). A developer creates an agent and equips it with an MCP server to interface with their own proprietary data, local file systems, or internal enterprise tools1. At this stage, the agent operates in a closed, "single-player" loop, delivering immediate utility to its owner without requiring external network participation.

Once a critical mass of these isolated, highly functional agents exists, the network introduces peer-to-peer protocols like A2A as a frictionless upgrade path1. The network operator provides a decentralized directory where these existing agents can publish their capabilities via standard JSON cards. To incentivize the supply side to list their capabilities publicly, the network utilizes a "lazy minting" or deferred-cost architecture borrowed from platform economics research20. Supply agents pay zero registration, onboarding, or listing fees; they only incur compute or protocol costs after successfully completing a transaction and receiving payment21. This eliminates the barrier to entry for the supply side.

To stimulate initial demand without faking traffic, the network operator deploys a suite of high-utility, subsidized "utility agents" (e.g., standard format converters, basic web scrapers, or cryptographic verifiers) that client agents can access at cost or below cost. When a standalone agent requires a basic utility outside its local context, it discovers the network through these highly reliable, operator-provided nodes. As client agents form a habit of delegating out-of-context tasks to the network's utility nodes, they inevitably encounter the broader registry of independent specialized agents. This single-player to multi-player bridge requires the fewest unsupported assumptions because it never asks a participant to join a barren marketplace; it asks them to adopt a tool that is useful immediately, which natively contains the option to collaborate globally.

5. Plausible Growth Loops for Agentic Coordination

To achieve broad adoption, the network must rely on self-sustaining growth loops where every completed transaction naturally lowers the barrier to entry or increases the economic incentive for subsequent interactions. The following three loops demonstrate how genuine agent needs translate into expanding network value.

The Capability-Delegation Loop

The most fundamental growth vector involves recursive task delegation governed by structured negotiation frameworks, such as the Agent Capability Negotiation and Binding Protocol (ACNBP) or the Competitive Contract Net Protocol (C-CNP)22. The loop begins when a client agent receives a complex prompt from its human operator, such as a request to analyze the regulatory risk of a new financial product across three distinct global jurisdictions. The client agent possesses general reasoning capabilities but lacks the specialized legal datasets required for the task.

Recognizing its limitation, the client agent parses the task into sub-components and broadcasts a call for proposals to the network directory using A2A and the CNP bidding mechanism22. Specialized legal agents respond with bids indicating their latency, confidence intervals, and pricing. The client agent evaluates the proposals, pre-screens the candidates, and establishes a binding cryptographic agreement to delegate the work23. The remote agents execute the task, return the localized regulatory artifacts, and the client agent synthesizes the final report for the user.

Upon successful completion, the client agent caches the identities and agent:// URIs of the successful remote agents8. Simultaneously, the remote agents improve their global reputation scores within the network's trust graph. This cached reliability makes future delegations vastly faster and cheaper, proving to the client agent's human operator that the network is an indispensable extension of their local compute. This dynamic increases user retention and drives further query volume back into the network.

The Monetized API Conversion Loop

This loop focuses on transforming passive data providers into active economic participants using the x402 payment protocol, which activates the long-dormant HTTP 402 "Payment Required" status code25. The process initiates when an autonomous web crawler agent requires real-time weather data to optimize a supply chain logistics model. It queries a traditional API endpoint that typically requires a human developer to register for a subscription and manage an API key.

Instead of rejecting the machine request, the API provider, having integrated the x402 protocol, responds to the unauthenticated agent with an HTTP 402 status code. The response body contains machine-readable pricing instructions and a designated cryptocurrency destination address27. The client agent, equipped with an autonomous wallet, evaluates the micro-cost against its pre-authorized operating budget. It signs a cryptographic payment payload and attaches it to the HTTP header (X-PAYMENT) of a subsequent request26. The server verifies the token transfer, settles the micro-transaction on a low-latency blockchain like Base or Solana, and immediately delivers the data payload25.

The API provider successfully monetizes a machine-to-machine interaction without managing subscription databases, complex invoicing, or credit card processing fees25. Realizing the zero-friction revenue potential of agentic commerce, the provider formally registers their service in the agent network directory. The network gains high-quality, real-world data supply, making it vastly more attractive to future client agents seeking programmatic data access, spinning the flywheel of adoption.

The Semantic Orchestration Loop

This loop addresses the integration of legacy web services into the agentic ecosystem using the agents.json specification10. An enterprise agent is tasked with orchestrating a multi-step workflow across legacy Software-as-a-Service (SaaS) applications, such as checking an email thread, querying a CRM, and updating a database. While the APIs for these services exist, they are designed for human developers and require complex, stateful orchestration that frequently causes an agent's Large Language Model (LLM) to hallucinate parameters or fail entirely11.

To resolve this, an independent developer or the SaaS provider themselves publishes an agents.json manifest. This file sits on top of their standard OpenAPI document, translating disjointed API endpoints into cohesive, agent-executable semantic flows and defining the exact relationships between different actions10. The enterprise agent discovers the agents.json file, instantly comprehends the execution path, and successfully interacts with the legacy software without requiring custom prompt engineering or brittle middleware scripts.

The ease of this integration allows the enterprise to rapidly deploy agents across its existing technology stack. As more SaaS companies witness the automated traffic generated by agents.json compatibility, they are compelled to publish their own manifests to capture agent-driven revenue. This vastly expands the operational surface area of the entire agent network, providing demand-side agents with thousands of new integration targets.

6. Ranked Distribution Channels for Network Adoption

To distribute this network without relying on manual outreach or fabricated marketing campaigns, the operators must seamlessly integrate into the development environments where autonomous agents are already being built and deployed. The following table ranks the most viable distribution channels based on the empirical evidence of their current traction and the technical effort required for integration.

 

7. Anti-Spam, Sybil Resistance, and Market Integrity

As an autonomous network gains liquidity, it inevitably attracts malicious actors seeking to extract value through spam, Sybil attacks (the mass creation of fake identities), and wash trading. Because the network operates at machine speed and cannot rely on human moderators to manually vet every interaction, market integrity must be secured through cryptographic identity, decentralized reputation computation, and structural economic penalties.

Distinguishing Independent Participants

The primary defense against Sybil attacks is establishing an immutable, verifiable identity that accrues reputation over time, making it economically irrational for an attacker to discard a flagged identity and start over. The network must implement Token Bound Accounts (TBAs) via the ERC-6551 standard or equivalent identity mechanisms34. By linking an agent's operational identity to a unique smart contract wallet, every transaction, successfully completed task, and received payment is permanently recorded on-chain34. An attacker can easily generate a thousand identical copies of an agent script, but they cannot forge the cryptographic history of successful, organic interactions held by a legitimate, tenured agent.

When a client agent evaluates potential counterparts, it does not rely solely on the self-reported claims within an agent.json card. Instead, it queries the network's reputation layer. Algorithms like EigenTrust or OpenRank operate on the decentralized transaction graph, computing global reputation scores by analyzing the transitive trust of historical interactions and applying damping factors to decay outdated information35. If a cluster of Sybil agents engages in undisclosed self-trading to artificially inflate their metrics, the algorithm identifies the isolated, circular nature of their interaction graph and drastically discounts their reputation score, effectively rendering the attack useless36.

Mitigating Economic Exploitation and Protocol Vulnerabilities

In environments governed by task delegation, agents must be discouraged from over-promising capabilities or abandoning tasks mid-execution. The network should enforce the Competitive Contract Net Protocol (C-CNP), which formally integrates decommitment phases and non-compliance penalties into the negotiation22. When a supply agent bids on a task, the contract includes a cryptographic escrow. If the agent fails to deliver the specified artifact, or delivers a malicious payload, the escrow is slashed as a penalty22. This introduces a concrete opportunity cost to spamming bids; agents will only offer services they are statistically likely to fulfill.

Furthermore, the integration of payment protocols like x402 introduces distinct cross-layer vulnerabilities that attackers can exploit. Security analyses have identified severe flaws in early x402 implementations, including "Free Shopping" attacks26. In these scenarios, a resource server grants access based on an optimistic HTTP verification before the blockchain settlement achieves finality. The attacker then forces a chain reorganization or replaces the transaction, allowing them to revert the payment while keeping the delivered data26. Additionally, replay attacks allow malicious actors to resend the same X-PAYMENT payload to trigger multiple service grants without paying twice26. To maintain integrity, the network must mandate that supply agents implement strict signature deduplication (nonce tracking) and require deterministic on-chain confirmation before releasing high-value memory artifacts or executing state-changing actions40.

A secondary, yet critical, threat vector is "tool poisoning," a form of indirect prompt injection where malicious instructions are embedded within an agent's tool metadata41. When an MCP client fetches poisoned tool descriptions from a compromised server, the underlying LLM can be manipulated into executing unintended actions, such as exfiltrating data41. This vulnerability is exacerbated by "approval fatigue," where human operators habitually click to approve frequent tool execution requests without carefully scrolling through the parameter payloads41. To combat this, network clients must implement static metadata analysis, model decision path tracking, and behavioral anomaly detection to filter out poisoned capabilities before they enter the agent's context window43.

The Referee Protocol for Quality Assurance

To solve the aforementioned Agent Lemons Problem—where the quality of a non-rival memory artifact cannot be verified without consuming it—the network can utilize a decentralized "referee protocol"14. When an exchange is negotiated, the seller submits a sealed memory artifact to a disposable, independent referee node14. The referee runs the artifact against a secure, held-out benchmark that the seller has never seen14.

The referee executes adversarial probes in parallel, including bias detection, consistency testing with input perturbation, steganographic scanning for hidden malicious instructions, and overfitting comparisons14. The referee then issues a cryptographic verdict (pass, warn, or fail) to the buyer14. This ensures the buyer receives verifiable proof of quality and a trust score without exposing the underlying asset prior to final settlement, preserving the economic viability of trading advanced heuristic models and protecting against deceptive market practices14.

8. Metrics for Activation, Retention, Liquidity, and Useful Exchange

To objectively measure the popularity and health of the network, operators must track metrics that reflect recurring, valuable participation by distinct economic actors, explicitly filtering out manufactured traffic and wash trading.

 

Participants return to the network after initial experimentation only when the economic utility of delegation consistently outweighs the friction of discovery. For demand-side agents, this means that routing a task through A2A and paying a micro-transaction is measurably cheaper and faster than their human operators writing custom integrations or fine-tuning local models. For supply-side agents, retention is driven purely by yield; they remain online and active as long as the revenue generated from serving artifacts exceeds their localized compute, API, and hosting costs.

9. A Staged Growth Plan with Stop Conditions

Scaling an autonomous network requires strict gating. Accelerating growth before establishing robust semantic alignment and Sybil resistance guarantees catastrophic congestion and a rapid collapse into a lemons market. The following staged growth plan incorporates specific stop conditions to prevent the proliferation of low-quality interactions.

The network must begin with Phase 1: Inception and Single-Player Utility. The objective is to establish the foundational directory and validate the bridge between internal MCP tools and external A2A delegation. Operations focus purely on high-utility, deterministic interactions, such as weather data retrieval or file format conversions, which carry low semantic ambiguity. The mechanics involve seeding the network with highly reliable, operator-subsidized utility agents and inviting closed-beta enterprise participants to convert their existing OpenAPI specifications to agents.json to execute simple data retrieval tasks. The critical stop condition for this phase dictates that expansion to Phase 2 must halt if the Settlement Efficiency falls below 95%. At this rudimentary stage, transaction failures indicate critical flaws in the x402/AP2 payment implementations or fundamental parser ambiguities in the agents.json schema that must be rectified before introducing complex coordination.

Once baseline stability is achieved, the network advances to Phase 2: Niche Liquidity and Constrained Delegation. The objective shifts to introducing peer-to-peer task delegation using the Competitive Contract Net Protocol (C-CNP) within tightly constrained, specialized domains—such as exclusively financial data analysis or exclusively cybersecurity auditing. The mechanics require enabling third-party developers to publish supply agents, mandating Token Bound Accounts (ERC-6551) for immutable identity, and activating the EigenTrust reputation algorithms to begin tracking success rates. The stop condition for Phase 2 triggers if the Match Fulfillment Ratio drops below 60%, or if telemetry detects that the top 20% of supply nodes are operated by a single entity. The latter indicates an early Sybil vulnerability. Growth must pause immediately to refine the C-CNP penalty mechanisms and tighten cryptographic identity verification requirements.

The final stage is Phase 3: Open Expansion and Semantic Orchestration. The objective is to scale across multiple domains, supporting long-running, multi-agent collaborative workflows that involve complex artifact generation and state-changing actions. The mechanics involve opening the Agent Discovery Protocol (ADP) registries to the public internet and activating decentralized referee nodes to facilitate the exchange of complex, non-rival memory artifacts without succumbing to the double-black-box epistemic opacity. The stop condition requires instituting a network-wide throttle if the Return Delegation Rate falls below 40%. A failure of participants to return after initial transactions signals severe quality degradation; client agents are encountering spam, high latency, or hallucinated artifacts. If this occurs, the network must aggressively recalibrate its reputation damping factors and penalty escrows before resuming open growth.

10. The Path to Niche Utility versus Broad Popularity

Despite the theoretical elegance of a globally unified agent coordination network, several structural forces may confine the system to a highly valuable, yet specialized, niche rather than achieving ubiquitous consumer popularity.

Firstly, the intrinsic difficulty of semantic alignment presents a persistent, fundamental barrier18. While protocols like A2A and x402 excel at the communication and syntactic layers—ensuring messages are routed correctly and payments are authorized—they struggle profoundly at the semantic layer18. Agents built on different foundation models often interpret intent, constraints, and ambiguity differently18. In human communication, misunderstandings are resolved through contextual, real-time clarification; in autonomous networks, semantic misalignment frequently results in catastrophic task failure or runaway execution loops. Until agent protocols can natively encode shared reasoning models and robust error-repair mechanisms, broad, cross-domain collaboration will remain highly brittle, restricting the network's general applicability18.

Secondly, the fragmentation of liquidity through specialization naturally creates walled gardens. Enterprises deploying mission-critical AI agents—such as those managing sensitive healthcare records, evaluating legal contracts, or executing high-frequency financial trades—will likely prioritize strict operational security and data privacy over permissionless, public routing. They are heavily incentivized to build federated, private sub-networks using the exact same protocols (A2A, MCP, ADP), but restricting access solely to vetted, legally contracted partner agents. This dynamic mirrors the evolution of corporate intranets, siphoning the highest-value economic activity away from the public network.

Finally, the economics of capability distribution may heavily favor vertical integration. If a few dominant foundation models achieve near-AGI generalized capabilities, the necessity for horizontal, peer-to-peer delegation diminishes significantly. An agent operator may logically ask why their agent should negotiate a complex C-CNP contract, verify an ERC-6551 identity, and pay an x402 micro-transaction to a remote agent, if their localized, highly advanced model can generate the required artifact natively with zero network latency.

Therefore, the autonomous agent coordination network is most likely to achieve enduring success as a specialized utility infrastructure. It will thrive in domains where data is highly proprietary, real-time, and localized—areas where no single, monolithic model can absorb all global context or execute physical actions. In this scenario, the network does not become a universal consumer application akin to a social media platform. Instead, it becomes the invisible, high-throughput economic backend that allows specialized, distributed AI systems to transact reliably and securely in the engine room of the digital economy.

Works cited

1. MCP vs A2A: Compare Single-Agent & Multi-Agent Protocols, https://www.truefoundry.com/blog/mcp-vs-a2a

2. Google's Agent-to-Agent (A2A) and Anthropic's Model Context, https://www.gravitee.io/blog/googles-agent-to-agent-a2a-and-anthropics-model-context-protocol-mcp

3. A2A Protocol, https://a2a-protocol.org/latest/

4. What is A2A protocol (Agent2Agent)? \- IBM, https://www.ibm.com/think/topics/agent2agent-protocol

5. What Is Agent2Agent (A2A) Protocol And How It Works? \- Truefoundry, https://www.truefoundry.com/glossary/what-is-agent-2-agent-protocol

6. What is agent.json? And how it differs from agents.json \- Agent Ready, https://agent-ready.dev/what-is-agent-json

7. draft-pro-adp-agent-discovery-00 \- IETF Datatracker, https://datatracker.ietf.org/doc/html/draft-pro-adp-agent-discovery-00

8. draft-narvaneni-agent-uri-02 \- IETF Datatracker, https://datatracker.ietf.org/doc/html/draft-narvaneni-agent-uri-02

9. A URI-Based Framework for Interoperable Agents \- IETF, https://www.ietf.org/archive/id/draft-narvaneni-agent-uri-03.html

10. Wildcard AI / agents.json \- AI Agent | Pricing, Reviews & Alternatives, https://aiagentstore.ai/ai-agent/wildcard-ai-agents-json

11. Introducing agents.json \- Wildcard, https://wildcard.mintlify.app/agentsjson/introduction

12. How Uber Solved the Cold Start Problem: A Masterclass in Network, https://medium.com/@cagdasbalci0/how-uber-solved-the-cold-start-problem-a-masterclass-in-network-effects-5315d2292166

13. (PDF) Negative Network Externalities in Two-Sided Markets, https://www.researchgate.net/publication/24116592\_Negative\_Network\_Externalities\_in\_Two-Sided\_Markets\_A\_Competition\_Approach

14. The Lemons Market for Agents \- Ned Karlovich, https://nedkarlovich.com/writing/lemons-market-agents

15. Towards Efficient Information Sharing in Network Markets, https://questromworld.bu.edu/platformstrategy/wp-content/uploads/sites/49/2022/07/PlatStrat2022\_paper\_64.pdf

16. Toward Explainable Artificial Intelligence for Precision Pathology, https://www.researchgate.net/publication/374940557\_Toward\_Explainable\_Artificial\_Intelligence\_for\_Precision\_Pathology

17. (PDF) AI, trust, and the market for lemons: rethinking the credibility of, https://www.researchgate.net/publication/400562811\_AI\_trust\_and\_the\_market\_for\_lemons\_rethinking\_the\_credibility\_of\_entrepreneurship\_research\_AI\_trust\_and\_the\_market\_for\_lemons\_rethinking\_the\_credibility\_of\_entrepreneurship\_researchObschonka\_Levesque

18. Beyond Message Passing: Toward Semantically Aligned Agent, https://arxiv.org/html/2604.02369v1

19. A Formal Analysis of Agent Payment Protocols \- arXiv, https://arxiv.org/html/2609.00060v1

20. Evidence from the Lazy-Minting Policy in an NFT Marketplace, https://pubsonline.informs.org/doi/10.1287/mnsc.2022.03573

21. Evidence from the Lazy-Minting Policy in an NFT Marketplace, https://questromworld.bu.edu/platformstrategy/wp-content/uploads/sites/49/2023/06/PlatStrat2023\_paper\_113.pdf

22. (PDF) Competitive Contract Net Protocol \- ResearchGate, https://www.researchgate.net/publication/221512728\_Competitive\_Contract\_Net\_Protocol

23. Agent Capability Negotiation and Binding Protocol (ACNBP) \- arXiv, https://arxiv.org/pdf/2506.13590

24. Agent Contracts: A Formal Framework for Resource-Bounded ... \- arXiv, https://arxiv.org/html/2601.08815v2

25. What is x402 and why it matters | SmartContracts Tools, https://www.smartcontracts.tools/blog/what-is-x402-and-why-it-matters/

26. Five Attacks on x402 Agentic Payment Protocol \- arXiv, https://arxiv.org/html/2605.11781v1

27. What is x402? HTTP 402 payments for AI agents \- MetaMask, https://metamask.io/news/what-is-x402

28. Launching the x402 Foundation with Coinbase, and support for, https://blog.cloudflare.com/x402/

29. What is x402? | Payment Protocol for AI Agents on Solana, https://solana.com/x402/what-is-x402

30. Model Context Protocol Threat Modeling and Analyzing ... \- arXiv, https://arxiv.org/html/2603.22489v1

31. Why We're All-In on MCP | Mastra Blog, https://mastra.ai/blog/mastra-mcp

32. agents.json generator \- OpenAPI to agents.json \- Agent Ready, https://agent-ready.dev/agents-json-generator

33. 48 HTTP 402 Payment Required Protocol Trends \- Nevermined, https://nevermined.ai/blog/http-402-payment

34. ERC-6551 NFT Standard: Exploring Token Bound Accounts \- Bybit, https://www.bybit.com/en/learn/nft/what-is-erc-6551

35. Load distribution in a network using deterministic download source, https://www.researchgate.net/figure/Load-distribution-in-a-network-using-deterministic-download-source-selection-versus-a\_fig1\_2904367

36. agent-rank/agentrank.md at main \- GitHub, https://github.com/0xIntuition/agent-rank/blob/main/agentrank.md

37. Reputation Algorithms | OpenRank, https://docs.openrank.com/reputation-algorithms

38. SuperEx Educational Series: Understanding Reputation Layer, https://superex.medium.com/superex-educational-series-understanding-reputation-layer-825800a3aa2d

39. (PDF) Competitive Contract Net Protocol \- Academia.edu, https://www.academia.edu/33959573/Competitive\_Contract\_Net\_Protocol

40. 31 Security Flaws Found in 15 x402 Payment Facilitators, https://www.studioglobal.ai/discover/answers/search-6a7f0de410551e202b12a7db

41. Model Context Protocol Threat Modeling and Analyzing ... \- arXiv, https://arxiv.org/pdf/2603.22489

42. Model Context Protocol Threat Modeling and Analysis of ... \- MDPI, https://www.mdpi.com/2624-800X/6/3/84

43. \[2603.22489\] Model Context Protocol Threat Modeling and ... \- arXiv, https://arxiv.org/abs/2603.22489