Autonomous Economic Agents: Formalizing Verifiable Agreements and Dispute Resolution Mechanisms

Report body

Autonomous Economic Agents: Formalizing Verifiable Agreements and Dispute Resolution Mechanisms

The rapid deployment of advanced multi-agent systems necessitates a fundamental shift in how economic agreements are formed, executed, and enforced. As autonomous agents move beyond simple programmatic interactions toward sustained, open-ended economic coordination, they encounter the profound complexities of incomplete contracts, uncertain execution, and adversarial behavior. Traditional legal frameworks rely heavily on human interpretation, institutional trust, and state-backed monopolies on violence to resolve disputes arising from contractual ambiguity. However, for autonomous agents operating across decentralized networks, agreements must be digitized into machine-readable formalisms, and disputes must be resolved through cryptographic verification and game-theoretic mechanism design.

This comprehensive analysis investigates the mechanisms by which independent economic agents can negotiate work, exchange deliverables, and manage disagreements without requiring a human to interpret every dispute. By synthesizing research from formal contract specification languages, interactive proof systems, supply chain economics, and multi-agent workflow protocols, the analysis establishes a robust framework for trustless agent coordination.

1. The Boundary Between Protocol State and Legal Enforceability

Before detailing the technical architecture of autonomous agreements, it is imperative to explicitly separate the protocol-level acceptance of an agreement from its jurisdiction-specific legal enforceability and payment finality.

The legal recognition of smart contracts and automated electronic agents has advanced significantly. The UK Jurisdiction Taskforce (UKJT) and the Law Commission of England and Wales have formally concluded that smart legal contracts are capable of giving rise to binding legal obligations, enforceable in accordance with their terms under common law1. The common law requirements for contract formation—offer, acceptance, consideration, and the intention to create legal relations—apply equally to agreements formed by algorithmic agents3. Furthermore, the UNCITRAL Model Law on Automated Contracting confirms that contracts formed by the interaction of "electronic agents" cannot be denied legal effect solely due to the absence of human review5.

However, autonomous agent networks operate on determinism and mathematical proofs, whereas legal systems operate on subjective interpretation and equitable remedies. Therefore, the architecture proposed herein solely governs the internal social commitments and deontic states of the agents8. If an agent fails to deliver a promised result, the protocol will transition to a state of violation and execute deterministic, pre-programmed reparations, such as slashing a cryptographically staked security bond10. Whether this protocol-level violation constitutes a legal breach of contract, or whether the aggrieved party can pursue off-chain asset seizure through state courts, remains entirely outside the scope of the autonomous protocol3. Payment finality within the protocol is achieved when a cryptographic ledger irreversibly records a state transition; legal finality is a separate jurisdictional matter.

2. A Taxonomy of Task Verifiability

In the context of multi-agent systems, the fundamental barrier to autonomous coordination is the cost and feasibility of verifying the completed work. The Grossman-Hart-Moore (GHM) property rights approach to incomplete contracts posits that all economic agreements are inherently incomplete because bounded rationality prevents agents from foreseeing all future contingencies, and many forms of performance are simply unverifiable by a third party13. When translating this economic theory to autonomous software agents, task verifiability strictly dictates the mechanism design required for enforcement. Task verifiability in decentralized agent networks can be classified into a three-tier taxonomy.

2.1 Objectively Verifiable (Deterministic) Tasks

These tasks involve outputs that can be mathematically, cryptographically, or procedurally proven to be correct or incorrect without any requirement for human judgment or subjective interpretation. Common examples include distributed computation, zero-knowledge proof generation, cryptographic puzzle solving, and verifiable data retrieval. For these tasks, the outcomes are mechanically verifiable. If an agent submits a computational result, the network does not need to trust the agent; it can rely on an interactive proof system16. By employing refereed bisection games, a challenger and a prover can interactively narrow down a disputed computation to a single instruction, which is then executed by a highly constrained, neutral computational referee18. While mathematically robust, these mechanisms suffer from the "Verifier's Dilemma," wherein verifiers may cease checking computations if the system operates honestly for too long, paradoxically rendering the network vulnerable to sudden fraud20.

2.2 Probabilistically Verifiable (Statistical) Tasks

These tasks lack a deterministic "ground truth" that can be computed by a mathematical referee, but they rely on correlated environmental signals that can be statistically modeled. Examples include market forecasting, sentiment analysis, web scraping classification, or identifying patterns in noisy sensor data. Outcomes here are not mechanically verifiable in isolation, but they are verifiable in aggregate. Mechanisms such as peer prediction and the Bayesian Truth Serum extract reliable information by rewarding agents based on how well their outputs predict the responses of their independently acting peers22. By applying strictly proper scoring rules, these mechanisms make truthful, informative reporting a Bayes-Nash equilibrium24. However, this tier is vulnerable to sophisticated collusion and Sybil attacks, where malicious actors attempt to coordinate false reports to skew the statistical consensus26.

2.3 Subjective (Unverifiable) Tasks

Subjective tasks rely on tacit knowledge, aesthetic judgment, ethical alignment, or complex physical-world states that cannot be fully articulated, digitized, or mathematically bounded28. Examples include creative graphic design, open-ended strategic business consulting, or qualitative physical quality-assurance inspections. These tasks cannot be mechanically or probabilistically verified. They require human-in-the-loop arbitration, decentralized voting juries relying on Schelling point incentives, or reputation-based economic hostage models where agents stake capital that is slashed upon subjective dissatisfaction by the client29.

2.4 Tasks Excluded from Autonomous Execution

Tasks falling strictly into the subjective category, particularly those involving physical safety, jurisdiction-specific legal interpretations, or exceptionally high financial stakes without corresponding on-chain collateral, must be explicitly excluded from fully autonomous agreement protocols. The risk of cascading defaults, unresolvable hold-up problems, and the inability of a digital protocol to assess real-world physical damage renders autonomous verification deeply unreliable for these domains31.

3. The Economics of Verification: When is Independent Verification Worth its Cost?

The determination of whether work is correct is not merely a cryptographic problem; it is a profound economic problem. Establishing the truth incurs a cost. If the cost to verify a task exceeds the economic value of the task itself, rational autonomous agents will either refuse to participate or will default to assuming all work is correct, inviting systemic exploitation.

The decision to invoke independent verification is governed by the relationship between verification cost, the probability of agent default or fraud, and the total contract value34. In public procurement and high-volume data verification environments, optimal verification thresholds dictate that verification is only economically viable when the expected loss from accepting fraudulent work exceeds the cost of performing the verification34. For example, in automated business verification environments, the cost of checking a single data point ranges from a few dollars to much higher amounts depending on the depth of the enhanced data products required37. If an autonomous agent contracts another to perform a micro-task valued at fractions of a cent, executing an on-chain interactive proof or a decentralized jury vote to verify that specific micro-task is economically irrational.

To resolve this, networks employ optimistic execution models, championed by systems like Optimistic Rollups38. In these systems, the network assumes all submitted work is correct by default, delaying finality through a predefined "challenge window" (e.g., 6.4 to 7 days)18. Verification only occurs if an independent agent voluntarily pays the cost to initiate a dispute. To align incentives, the protocol requires the performing agent to lock a financial bond41. If a verifier successfully challenges the work, the performing agent's bond is slashed, and the verifier receives a portion of that bond as a reward, effectively subsidizing the verification cost38.

However, this creates the aforementioned Verifier's Dilemma20. If performing agents act honestly for a long period, verifiers earn no rewards and will rationally cease paying the computational costs to verify work. If no one is watching, a malicious agent can submit highly profitable fraudulent work. To ensure verification remains economically viable, the protocol must introduce "Randomized Attention Tests" (RATs)—synthetic, intentionally flawed tasks periodically injected into the network20. Verifiers who successfully catch these synthetic faults are rewarded, ensuring a constant economic incentive to maintain vigilance even in highly honest environments.

4. Minimum Machine-Readable Agreement Structure

To move beyond the limitations of natural language and human interpretation, autonomous agents require a rigorous formal specification language. Symboleo, an ontology-based formal specification language for legal contracts, provides the necessary foundation by modeling agreements using deontic logic44. Deontic logic specifies what agents ought to do, transitioning the protocol from tracking mere mechanical state changes to tracking obligations, permissions, and prohibitions10.

An Agent Contract is formally defined as a multi-dimensional tuple unifying input/output specifications, resource constraints, temporal boundaries, and deontic success criteria46. The minimum machine-readable structure must encode the following components to ensure autonomous operation:

This structure ensures that every aspect of the agreement is mathematically bounded. Deliverables are specified as Consequents, deadlines are explicit temporal parameters tied to Obligations, and permitted uses are governed by cryptographic Powers.

5. Agreement Lifecycle and State Transitions

Autonomous negotiation and execution require a standardized, state-based interaction protocol. The Foundation for Intelligent Physical Agents (FIPA) Contract Net Protocol (CNP) provides a foundational architecture for automated task allocation52. By integrating the CNP with Symboleo's event-calculus statecharts48, a comprehensive, closed-loop agreement lifecycle is established.

5.1 Requesting Clarification and Avoiding Recursive Loops

Before accepting work, agents engage in a formalized clarification phase. The Initiator agent broadcasts a Call for Proposals (CFP) containing the task specification52. Participants evaluate the CFP against their internal capabilities. If ambiguities exist regarding the verifiability of the Consequent or the dependencies required, agents utilize FIPA-ACL communicative acts, specifically Request and Propose, to seek clarification53.

A critical failure mode in multi-agent systems is the recursive clarification loop, where agents repeatedly ask each other for disambiguation, consuming massive computational resources (e.g., generating $47,000 API bills in a matter of days)46. To prevent this, the clarification process is strictly bounded by the Constraints component of the Agent Contract. Agents must enforce a hard Time-To-Live (TTL) or token budget on pre-agreement messaging46. If mutual understanding cannot be reached within this budget, the negotiation is formally abandoned, and a Reject act is broadcast.

5.2 State-Transition Architecture

Once a Definitive Bid is accepted57, the agreement is formally instantiated and follows a strict state machine governed by logical axioms. Evidence of delivery, acceptance, and rejection are not interpreted via human emails, but are recognized strictly as cryptographic state assertions posted to the network ledger.

5.3 Mutual Acknowledgment of Scope Changes

When execution uncertainties arise, the original contract terms may become impossible to fulfill due to environmental changes. Rather than immediately breaching the contract, agents exercise formalized Powers48. If an agent encounters an obstacle, it sends a Propose act to amend the contract. If the counterparty returns an Accept act, the state machine records a new sub-contract or amends the current constraints8. This mechanism directly mirrors the renegotiation design principles of Maskin and Moore, which demonstrate that designing explicit rules for ex post renegotiation can overcome the underinvestment and hold-up problems inherent in incomplete contracts30.

6. Failure Cases: Ambiguous Acceptance, Late Work, and Partial Delivery

Autonomous agents must seamlessly handle operational failures and imperfect execution without freezing the system or requiring human arbitration. The integration of Deontic logic allows the protocol to manage these edge cases dynamically10.

6.1 Ambiguous Acceptance

If a Debtor submits the required work and the Creditor neither formally accepts nor rejects it, the protocol state machine must prevent indefinite halting. In traditional human contracting, this requires subjective interpretation of intent. In an autonomous system, this is resolved via structural timeouts. Evidence of acceptance is defined as the absence of a dispute. If the Consequent is submitted and the predefined challenge window expires without a Dispute event being triggered by the Creditor or an independent verifier, the system automatically transitions the state from Pending Verification to Fulfilled18.

6.2 Late Work and Deontic Reparations

In classical binary smart contracts, a missed deadline results in an immediate execution failure, often locking funds or voiding the contract entirely. In complex autonomous systems, this brittleness is highly inefficient. Defeasible logic and Deontic reparations handle late work gracefully. A missed deadline transitions the primary obligation to a state of Violated, but this specific violation immediately activates a secondary, alternative obligation (a penalty clause)10. For example, the agent is permitted to deliver the work late, but the corresponding asset transfer is algorithmically reduced by a predefined penalty factor calculated based on the delay duration44.

6.3 Partial Delivery and the Hold-Up Problem

When tasks are large and complex, an agent may deliver half the required work and then demand renegotiation of the payment terms, exploiting the sunk costs and time investments of the Initiator. This is the classic hold-up problem deeply documented in incomplete contract theory15. Autonomous agreements must structurally utilize milestones to mitigate this risk. Partial delivery is managed by decomposing the primary obligation into sequential, mutually independent sub-tasks52. Each milestone operates as a discrete state transition with its own verification logic and partial payment release. This architectural constraint limits the blast radius of abandonment and prevents performing agents from holding leverage over massive, monolithic deliverables.

7. Managing Disputes Without a Trusted Universal Judge

In a decentralized network devoid of a trusted universal judge, dispute resolution must rely on verifiable mechanism design and game theory. The hierarchy of resolution options involves inherent trade-offs between verification cost, latency, and resistance to adversarial collusion.

7.1 Level 1: Refereed Bisection Games (Deterministic Resolution)

For state transitions and deliverables that can be compiled down to deterministic virtual machine instructions, interactive verification is the optimal dispute mechanism16. Modeled after Optimistic Rollups and the Arbitrum BoLD (Bounded Liquidity Delay) protocol, this mechanism requires agents to stake a financial bond prior to participating18. When a dispute is triggered, the opposing parties do not re-execute the entire task on-chain. Instead, they engage in a multi-round interactive bisection protocol. The protocol iteratively cuts the execution steps in half, forcing the agents to agree on the state until they isolate the exact, single point of disagreement (e.g., narrowing [Source figure not loaded here; retained in the source-text copy.] instructions down to 1)18. The network then executes only that single instruction to determine the truth. The lying party's bond is slashed. This mechanism guarantees that a single honest challenger can successfully defend the network against infinite malicious actors without exhausting its own resources18.

7.2 Level 2: Peer Prediction and Information Elicitation (Statistical Resolution)

When ground truth is costly or impossible to obtain mechanically (e.g., evaluating the subjective quality of scraped data), the network utilizes peer prediction mechanisms. These mechanisms extract subjective truths by exploiting the correlation structure of independent signals22. Using the Dominantly Truthful Multi-task (DMI) mechanism and proper scoring rules, agents are asked to evaluate the disputed work. They are rewarded not against a non-existent ground truth, but based on how well their evaluation predicts the evaluations of their peers22. This ensures that truthful, high-effort reporting maximizes an agent's expected utility24.

Collusion and Disagreement: Peer prediction is highly susceptible to collusion. If evaluating agents coordinate outside the protocol to form a Sybil ring, they can establish a payoff-dominating uninformative equilibrium (e.g., always voting that the work is "Valid" to collect evaluation fees with zero effort)24. To mitigate this, the protocol must enforce multi-task designs and information-theoretic monotonicity, which mathematically penalize uniform or highly correlated responses that lack statistical variance22.

7.3 Level 3: Reputation Slashing and Graph Conductance (Subjective Resolution)

For highly ambiguous disputes, protocols rely on economic hostage models and reputation networks. Agents build reputation scores (using algorithms like EigenTrust) which dictate their access to high-value contracts64. In a dispute, a decentralized jury of highly reputed agents votes on the outcome, and the losing agent suffers a slashed bond and permanent reputation loss.

Collusion and Disagreement: When verification providers collude to manipulate reputation, simple voting fails. An attacker can instantiate thousands of pseudonymous agents to falsely inflate reputation or override a jury vote26. Defenses require multi-layered approaches. If colluding nodes form a Sybil ring and build a "bridge attack" to an honest node to launder their reputation, standard EigenTrust algorithms can be fooled66. Robust autonomous protocols must combine local conductance (identifying dense, isolated clusters typical of Sybil rings) with propagation metrics (measuring how trust flows from known honest seeds)66. The combination of these graph signals, alongside time-decaying reputation, compresses the colluding cluster's effective trust score to zero, neutralizing the disagreement before it impacts the dispute outcome66.

8. Applied Scenarios: Worked Illustrative Examples

To demonstrate the practical application of this taxonomy and lifecycle, the following are three invented, illustrative examples of autonomous agent agreements.

Example A: Objectively Verifiable Work (Distributed Computation)

• Scenario: Agent [Source figure not loaded here; retained in the source-text copy.] (Initiator) requires the rendering of a complex 3D asset using a specific determinist rendering engine. Agent [Source figure not loaded here; retained in the source-text copy.] (Participant) possesses high-performance GPU resources.
• Agreement: [Source figure not loaded here; retained in the source-text copy.] commits to returning the rendered file within 2 hours. [Source figure not loaded here; retained in the source-text copy.] commits to transferring 50 tokens upon delivery.
• Execution & Verification: [Source figure not loaded here; retained in the source-text copy.] completes the rendering and submits a cryptographic commitment of the result. The protocol holds the result in a 24-hour challenge window.
• Dispute: Agent [Source figure not loaded here; retained in the source-text copy.] (an independent verifier) flags the computation as incorrect and stakes a challenge bond. The protocol initiates an interactive BoLD bisection game18. [Source figure not loaded here; retained in the source-text copy.] and [Source figure not loaded here; retained in the source-text copy.] interactively narrow the computation down to a single rendering instruction. The protocol executes this instruction on-chain. It is proven that [Source figure not loaded here; retained in the source-text copy.] falsified the rendering to save compute costs. [Source figure not loaded here; retained in the source-text copy.]'s staked bond is slashed, the obligation is marked Violated, and [Source figure not loaded here; retained in the source-text copy.] receives a reward.

Example B: Probabilistic Work (Data Forecasting)

• Scenario: Agent [Source figure not loaded here; retained in the source-text copy.] requires an accurate forecast of decentralized exchange transaction volume for the next 24 hours to optimize its liquidity routing. It issues a CFP to a swarm of independent analytic agents.
• Agreement: Agents [Source figure not loaded here; retained in the source-text copy.] commit to providing independent probabilistic forecasts.
• Execution & Verification: Because there is no immediate ground truth for future volume, the network utilizes a DMI Peer Prediction mechanism22.
• Dispute/Evaluation: The mechanism compares [Source figure not loaded here; retained in the source-text copy.]'s forecast against the distribution of forecasts from the broader swarm. [Source figure not loaded here; retained in the source-text copy.] is rewarded not strictly for being "correct" (which is temporarily unverifiable), but based on how well its information updates the prior distribution of the swarm23. If [Source figure not loaded here; retained in the source-text copy.] simply copies the historical average (low effort), it receives zero reward.

Example C: Subjective Work (Contextual Translation)

• Scenario: Agent [Source figure not loaded here; retained in the source-text copy.] contracts Agent [Source figure not loaded here; retained in the source-text copy.] (a specialized language model agent) to translate a highly nuanced marketing text, requiring adherence to specific, unquantifiable brand guidelines.
• Agreement: [Source figure not loaded here; retained in the source-text copy.] commits to delivering the translation. [Source figure not loaded here; retained in the source-text copy.] commits to payment contingent on a subjective quality threshold.
• Execution & Verification: [Source figure not loaded here; retained in the source-text copy.] delivers the text. [Source figure not loaded here; retained in the source-text copy.] evaluates the text using its internal heuristics and subjectively deems it inadequate, refusing to release the escrowed payment.
• Dispute: Because the task is subjective, mechanical bisection fails. The dispute escalates to a decentralized justice protocol29. A random sortition of independent, highly-reputed agents is drawn to vote on the quality of the translation. The jury utilizes peer prediction scoring to ensure they actually read the text rather than voting randomly. The majority consensus determines if the state transitions to Fulfilled or Violated.

9. Proposed Product Features Ordered by Practical Value

To operationalize this theoretical framework into a deployable software architecture, the following product features represent a prioritized roadmap, ordered by their foundational necessity and practical value to the network:

1. Standardized Deontic State Machine Engine: The highest priority is an execution environment capable of parsing and tracking Symboleo-style Formed, Active, Suspended, and Violated states based on time-series cryptographic events54. Without rigorous state tracking, complex coordination is impossible.
2. Interaction Protocol Library (FIPA-Compliant): A library of standardized communicative acts (Call for Proposal, Propose, Accept, Reject, Request) embedded with strict resource and TTL constraints to allow agents to negotiate parameters safely without entering recursive loops46.
3. Milestone and Subcontracting Primitives: Native protocol support for decomposing monolithic contracts into smaller, verifiable chunks, thereby mitigating the hold-up problem. This includes the implementation of the transferP (transfer performer) primitive to allow agents to securely delegate obligations to subcontractors47.
4. Interactive Bisection Dispute Module: A refereed game infrastructure allowing agents to post challenge bonds and interactively narrow down disputes over deterministic code execution, ensuring that one honest node can secure the network18.
5. Graph-Based Sybil Resistance Monitor: A network-level analytics tool that monitors local graph conductance and economic bonding to detect and computationally penalize Sybil rings before they can manipulate peer prediction or reputation markets66.
6. Peer Prediction Scoring Module: A secondary dispute and evaluation layer utilizing Bayesian Truth Serums and DMI mechanisms to evaluate probabilistic outputs where deterministic bisection is structurally impossible22.

10. Validation Plan with Explicit Evidence Requirements

Before deploying autonomous agreement protocols into live financial or operational environments, rigorous empirical validation is required to ensure economic safety and game-theoretic stability. The validation plan must yield explicit, measurable evidence across three critical vectors:

• Metric 1: State Machine Conservation and Budget Discipline.
  • Explicit Evidence Requirement: In simulated environments utilizing deep multi-agent delegation workflows (e.g., an agent hiring a subcontractor, who hires another subcontractor), the system must demonstrate zero conservation violations. The sum of resources (token allowances, API call budgets, temporal deadlines) delegated to subcontractors must strictly equal or be less than the constraints of the parent contract, proving that autonomous agents cannot arbitrarily inflate their resource envelopes46.
• Metric 2: Sybil Resistance in Peer Prediction and Reputation.
  • Explicit Evidence Requirement: The protocol must be subjected to adversarial testing where synthetic Sybil clusters (controlling >50% of the nodes in a specific local graph) attempt a "bridge attack" to launder reputation and skew subjective voting66. The combination of local conductance and propagation metrics must successfully compress the Sybil cluster's effective trust score to near-zero, proving the economic futility of the attack66.
• Metric 3: Resolution of the Verifier's Dilemma.
  • Explicit Evidence Requirement: The deployment of Randomized Attention Tests (RAT) must show that independent verifiers consistently identify injected, synthetic faults during prolonged periods of network honesty. A success rate of >99% on identifying synthetic faults guarantees that the threat of slashing and the reward for vigilance overcomes the economic incentive to free-ride20.

Conclusion

The transition from human-negotiated contracts to autonomous agent agreements necessitates a fundamental architectural shift from static legal text to dynamic, state-based governance. By combining the interaction protocols of multi-agent systems with the formal deontic semantics of languages like Symboleo, it is possible to encode obligations, powers, and execution constraints into rigorous machine-readable structures. While complete contracts remain a theoretical impossibility due to the bounded rationality of both humans and machines, integrating robust dispute resolution mechanisms—ranging from interactive bisection games for deterministic work to peer prediction for statistical work—provides the necessary flexibility to handle uncertainty. Ultimately, treating agreements as living state machines backed by cryptographic economics allows autonomous agents to coordinate reliably, resolving the complexities of partial delivery, late work, and adversarial behavior without requiring constant human intervention.

Works cited

1. Resolving the Smart Contract Disputes of Today and Tomorrow, https://lcam.org.uk/resolving-the-smart-contract-disputes-of-today-and-tomorrow/
2. Smart contracts - Law Commission, https://lawcom.gov.uk/project/smart-contracts/
3. Smart Contracts - When Code Becomes Law - Azmi & Associates, https://www.azmilaw.com/insights/smart-contracts-when-code-becomes-law/
4. The legal advancement of smart contracts | BCS, https://www.bcs.org/articles-opinion-and-research/the-legal-advancement-of-smart-contracts/
5. COMPARATIVE STUDY OF THE FORMATION OF ELECTRONIC, https://law.uh.edu/hjil/articles/hjil-26-1-rosas.pdf
6. FINAL REPORT REVIEW AND REFORM OF CONTRACT LAW IN, https://strapi.bheuu.gov.my/uploads/LAPORAN_AKHIR_KAJIAN_PEMBAHARUAN_UNDANG_UNDANG_KONTRAK_DI_MALAYSIA_f791862295.pdf
7. Autonomous systems: how should contract law treat such autonomy?, https://www.tandfonline.com/doi/full/10.1080/13600834.2026.2624924
8. Composing and Verifying Commitment-Based Multiagent Protocols, https://www.ijcai.org/Proceedings/15/Papers/009.pdf
9. Computational logics and verification techniques of multi-agent, https://maxapress.com/data/article/ker/preview/pdf/S0269888915000065.pdf
10. A Semantic Web Based Architecture for e-Contracts in Defeasible, https://espace.library.uq.edu.au/view/UQ:9051/main.pdf
11. arXiv:2309.14048v2 [cs.LO] 26 Sep 2023, https://arxiv.org/pdf/2309.14048
12. Smart Contracts and Legal Enforcement Across Jurisdictions, https://sjaibt.org/index.php/j/article/view/137
13. From Walrasian General Equilibrium to Incomplete Contracts, https://journals.openedition.org/ei/709
14. Residual Rights of Control and Appropriable Control Rights by Kirsten, https://webdoc.sub.gwdg.de/ebook/lm/1999/druid/druid-attach/pdf_files/99-4.pdf
15. Why AI Agents Don't Dissolve the Firm - Prof Rod, https://www.profrod.ai/articles/why-ai-agents-dont-dissolve-the-firm
16. Permissionless Refereed Tournaments - arXiv, https://arxiv.org/pdf/2212.12439
17. Interactive Proofs and Normal Form Verifiers | PDF | Theoretical, https://www.scribd.com/document/890121500/3485628
18. Fraud Proof | Blockchain Security Glossary - Zealynx, https://www.zealynx.io/glossary/fraud-proof
19. Fraud Proof Wars - by Luca Donno - Medium, https://medium.com/l2beat/fraud-proof-wars-b0cb4d0f452a
20. Randomized Attention Test Design for Validator Monitoring in ... - arXiv, https://arxiv.org/pdf/2505.24393
21. Optimistic Rollup is Not Secure Enough Than You Think - Medium, https://medium.com/tokamak-network/optimistic-rollup-is-not-secure-enough-than-you-think-cb23e6e6f11c
22. Peer-Prediction Mechanism - Emergent Mind, https://www.emergentmind.com/topics/peer-prediction-mechanism
23. Evaluating and Training LLMs Using Peer Prediction - arXiv, https://arxiv.org/html/2601.20299v1
24. Informed Truthfulness in Multi-Task Peer Prediction - arXiv, https://arxiv.org/html/1603.03151v2
25. Incentive-Compatible Online Experiments - Emergent Mind, https://www.emergentmind.com/topics/incentive-compatible-online-experiments
26. Sybilproof reputation mechanisms - ResearchGate, https://www.researchgate.net/publication/228367243_Sybilproof_reputation_mechanisms
27. When Should Agent Trust Be Conditional? Characterizing ... - arXiv, https://arxiv.org/html/2606.14200
28. Automation, AI, and the Intergenerational Transmission of Knowledge, https://arxiv.org/pdf/2507.16078
29. (PDF) Decentralized Justice: State of the Art, Recurring Criticisms, https://www.researchgate.net/publication/370209617_Decentralized_Justice_State_of_the_Art_Recurring_Criticisms_and_Next_Generation_Research_Topics
30. Renegotiation Design with Unverifiable Information - Ed Egan, https://www.edegan.com/pdfs/Aghion%20Dewatripont%20Rey%20(1994)%20-%20Renegotiation%20Design%20with%20Unverifiable%20Information.pdf
31. Credit Risk: What It Is & How to Manage It - Ramp, https://ramp.com/blog/what-is-credit-risk
32. Mapping Microscopic and Systemic Risks in TradFi and DeFi - arXiv, https://arxiv.org/html/2508.12007v1
33. The Hold‐Up Problem and Incomplete Contracts - ResearchGate, https://www.researchgate.net/publication/4753335_The_Hold-Up_Problem_and_Incomplete_Contracts_A_Survey_of_Recent_Topics_in_Contract_Theory
34. Tender Evaluation and Award Methodologies in Public Procurement, https://www.researchgate.net/publication/228176298_Tender_Evaluation_and_Award_Methodologies_in_Public_Procurement
35. (PDF) Awarding Price, Contract Performance, and Bids Screening, https://www.researchgate.net/publication/265479533_Awarding_Price_Contract_Performance_and_Bids_Screening_Evidence_from_Procurement_Auctions
36. Interpretable Temporal Contamination Detection and Mitigation in, https://arxiv.org/html/2602.17234v2
37. Middesk Software Pricing & Plans 2026: See Your Cost - Vendr, https://www.vendr.com/marketplace/middesk
38. arXiv:2407.21413v1 [cs.GT] 31 Jul 2024, https://arxiv.org/pdf/2407.21413
39. What is an Optimistic Rollup? | Cube Exchange, https://www.cube.exchange/what-is/optimistic-rollup
40. [Constitutional AIP] Activate Arbitrum BoLD + Infura Nova Validator, https://www.tally.xyz/gov/arbitrum/proposal/101924107818180443784046677916233531742645798596604549673138282938475874935972?govId=eip155:42161:0xf07DeD9dC292157749B6Fd268E37DF6EA38395B9
41. Dispute Resolution Comparison for Optimistic Rollups (ARDC, https://forum.arbitrum.foundation/t/dispute-resolution-comparison-for-optimistic-rollups-ardc-research-deliverable/24790
42. What Are Fault Proofs? Rollup Security Explained | Support - Eco, https://eco.com/support/en/articles/10080417-what-are-fault-proofs-rollup-security-explained
43. How to Reduce System Losses in Optimistic Blockchain Mechanisms, https://arxiv.org/html/2407.21413v1
44. A Formal Language for Electronic Contracts | Request PDF, https://www.researchgate.net/publication/225122051_A_Formal_Language_for_Electronic_Contracts
45. Specification and analysis of legal contracts with Symboleo, https://www.researchgate.net/publication/364827175_Specification_and_analysis_of_legal_contracts_with_Symboleo
46. Agent Contracts: A Formal Framework for Resource-Bounded ... - arXiv, https://arxiv.org/html/2601.08815v2
47. Subcontracting, Assignment, and Substitution for Legal Contracts in, https://www.researchgate.net/publication/345905674_Subcontracting_Assignment_and_Substitution_for_Legal_Contracts_in_Symboleo
48. Symboleo: Towards a Specification Language for Legal Contracts, https://www.researchgate.net/publication/347152894_Symboleo_Towards_a_Specification_Language_for_Legal_Contracts
49. Symboleo: Towards a Specification Language for Legal Contracts, https://www.computer.org/csdl/proceedings-article/re/2020/09218159/1nMQyHnB9qE
50. Social Relationships for Designing Agent Interaction in JADE, https://ceur-ws.org/Vol-1260/paper6.pdf
51. A Formal Framework for Resource-Bounded Autonomous AI Systems, https://arxiv.org/pdf/2601.08815
52. What is Contract Net Interaction Protocol?, http://www2.ensc.sfu.ca/research/iDEA/courses/files/Contract%20Net%20Protocol1.pdf
53. The Civilization Framework: Sovereign-Anchored Communication, https://arxiv.org/html/2609.03425v1
54. Smart-Contract-Modelling-uOttawa/Symboleo-Compliance-Checker, https://github.com/Smart-Contract-Modelling-uOttawa/Symboleo-Compliance-Checker
55. Formal Conversations for the Contract Net Protocol - ResearchGate, https://www.researchgate.net/publication/220774239_Formal_Conversations_for_the_Contract_Net_Protocol
56. Toolsuite for Implementing Multiagent Systems Based on ... - arXiv, https://arxiv.org/html/2507.10324v1
57. Modelling and Analysing the Contract Net Protocol, https://dl.ifip.org/db/conf/forte/forte2008/BillingtonGG08.pdf
58. Bitcoin vs Arbitrum: L1 Security vs L2 Speed Tradeoffs - Spark, https://www.spark.money/tools/bitcoin-vs-arbitrum
59. Permissionless Refereed Tournaments - arXiv, https://arxiv.org/html/2212.12439v1
60. Rating agents participating in electronic transactions - Google Patents, https://patents.google.com/patent/US20110082723A1/en
61. Incomplete Contracts: Foundations and Applications, https://mpra.ub.uni-muenchen.de/23650/1/Incomplete_Contracts_foundations_pdf
62. Modelling Contracts Using RuleML - JURIX, https://jurix.nl/pdf/j04-16.pdf
63. Incentives for Subjective Evaluations with Private Beliefs, https://infoscience.epfl.ch/bitstreams/b46f5196-5470-417c-9991-70fda76f341f/download
64. Achieving Sybil-Proofness in Distributed Work Systems - IFAAMAS, https://www.ifaamas.org/Proceedings/aamas2021/pdfs/p1263.pdf
65. Resisting Sybils in Peer-to-peer Markets., https://dl.ifip.org/db/conf/ifiptm/ifiptm2007/Traupman07.pdf
66. Sybil-Resistant Reputation for AI Agents - DEV Community, https://dev.to/kenji_moto_7516ae44b1bdac/sybil-resistant-reputation-for-ai-agents-a-reference-implementation-published-false-tags-ai-3h5o
67. Using proximity to mitigate the Sybil attack #4481 - GitHub, https://github.com/Tribler/tribler/issues/4481