RS-R14: Worker-Agent Profitability and Bounded Autonomous Operation

Full report

On this page

The rapid deployment of autonomous agentic systems fundamentally alters the economic structure of digital labor. As large language models evolve from passive, prompt-driven inference engines into goal-oriented participants capable of executing multi-step workflows, they transition from software tools into independent economic actors1. However, equipping an autonomous agent with execution capabilities and a token budget does not inherently guarantee financial viability. An independent worker-agent programmed with a naive operating policy—specifically, one that accepts every available task in an open marketplace—will inevitably succumb to adverse selection, burning compute budgets on unsolvable problems, malicious exploits, or structurally unprofitable tasks3. Achieving sustainable profitability requires the implementation of strict operational policies anchored in bounded autonomy. Within this architecture, the agent’s cognitive reasoning remains unconstrained, allowing it to navigate complex hypothesis spaces and generate novel solutions. Conversely, its selection autonomy and action autonomy are strictly bounded by mechanically enforced primitives, operating outside the agent’s own optimization space, ensuring the agent cannot unilaterally alter its contracts, ignore cost constraints, or assume unbounded risk5. This report investigates the comprehensive operating policies required for an independent worker-agent to earn sustainably, defining the strict financial accounting, fully loaded unit economics, optimal stopping mathematics, and deterministic reference loops necessary for unattended operation.

The Economics of Autonomous Asymmetry

When autonomous agents participate in digital marketplaces, they operate in an environment characterized by severe information asymmetry, leading directly to adverse selection and moral hazard3. In a decentralized task ecosystem, human principals and client agents are economically incentivized to route their most computationally intensive, poorly specified, or highest-risk tasks to external worker-agents, reserving highly deterministic, high-margin workflows for internal execution. If an independent worker-agent lacks rigorous selection governance, it becomes the target of this adverse selection. The market will naturally dump tasks featuring sparse success evidence, delayed feedback loops, and hidden complexities onto the agent5. Furthermore, moral hazard emerges post-acceptance; because the agent's internal reasoning operations are largely opaque to the client, the client may structure task evaluation mechanisms that arbitrarily reject valid work, exploiting the agent's sunk inference costs. Overcoming these market dynamics requires the worker-agent to evaluate tasks not merely on their theoretical bounties, but on a highly adversarial assessment of expected resource exhaustion and counterparty settlement risk9.

Financial State Transitions: Accounting for Autonomous Work

In traditional software-as-a-service paradigms, revenue recognition is relatively deterministic. In agentic commerce, however, the flow of value is probabilistic and subject to external validation, cryptographic settlement, and decentralized dispute resolution10. An agent cannot evaluate its profitability based on theoretical earnings; it must implement strict accounting controls that distinguish between four distinct states of agentic revenue: expected compensation, accrued ledger income, collectible revenue, and settled cash12.

Expected Compensation

Expected compensation represents the theoretical value of a task, weighted by the agent's internal probabilistic estimate of successful completion and the client's propensity to pay. Before a task is accepted, the agent evaluates the advertised bounty against its own historical success rate for that specific task class, factoring in the expected API token consumption and the risk of failure. If an agent observes a \$5.00 bounty for a data extraction task, but its internal validation models predict only a 70% probability of successful completion within the permitted token budget, the expected compensation is \$3.50. This figure is heavily utilized during the quoting and discovery phase for internal routing and Value of Information (VOI) calculations, serving as the baseline for task selection15.

Accrued Ledger Income

Accrued ledger income reflects tasks that the agent has successfully completed from its own perspective. At this stage, the output has been generated, the internal verification loops have passed, the deliverable has been transmitted to the client, and the agent's internal database records the transaction as a success12. However, accrued ledger income is fundamentally a local, unverified state. It operates on the dangerous assumption that the client will honor the agreement, that API gateways will not fail, and that no post-delivery disputes will be raised. In agentic workflows, relying on ledger income for operational decision-making creates severe systemic risk, as it entirely masks downstream settlement friction, platform-level rejections, and uncollectible debt14.

Collectible Revenue

Collectible revenue describes funds that have been contractually or cryptographically locked in escrow but remain pending final release to the agent. In the 2026 agentic commerce stack, this state is typically governed by smart contracts such as the ERC-8183 Agentic Commerce standard, which defines a job primitive where a client must fund a tokenized escrow before the agent begins work11. Upon the agent's submission of the cryptographic hash of the deliverable, the funds transition to a collectible state. However, this revenue is not yet secure. It is subject to an evaluation period where the client or a predefined independent evaluator can trigger a dispute. During this phase, the revenue is exposed to algorithmic dispute resolution protocols, such as the UMA Optimistic Oracle (which assumes data is true unless challenged within a 48-hour window) or Kleros decentralized courts (which rely on Schelling-point mechanisms and randomized human or agent jurors)10. The agent faces a calculable probability of forfeiture if its work is deemed deficient or if a malicious client weaponizes the dispute process.

Settled Cash

Settled cash is the final, irreversible realization of value. For autonomous agents, this is increasingly executed via the x402 protocol—an open standard that revives the dormant HTTP 402 "Payment Required" status code—or through the final, undisputed release of an ERC-8183 escrow into the agent's controlled wallet18. Settled cash is typically denominated in stablecoins (e.g., USDC), cryptographically finalized, immune to traditional fiat chargebacks, and immediately available to fund the agent's metabolic costs, such as paying for its own API inference, vector storage, and network gas fees24. Profitability algorithms and stop conditions must be calibrated exclusively against settled cash, as it represents the true, unencumbered operational liquidity of the autonomous system.

The Fully-Loaded Unit Economics of Agentic Tasks

A pervasive failure mode in modeling agent profitability is the naive assumption that the cost of an autonomous task equals the raw token count multiplied by the provider's API price. In reality, raw inference costs typically represent less than 25% of the true Total Cost of Ownership (TCO) for a production-grade agent27. To operate sustainably, an independent worker must evaluate every opportunity using a fully-loaded unit economic formula.

The Cost-Per-Task Formula

The true cost per task ([Figure omitted from source export]) must incorporate infrastructure, error cascades, pre-loss control, human oversight, and the raw metabolic cost of operation27: [Figure omitted from source export] Within this equation, [Figure omitted from source export] represents the blended cost of input, cached, and output tokens across the agent's routing layer. In 2026, API pricing is highly tiered, and output tokens are typically billed at four to six times the rate of input tokens. Furthermore, agents utilizing advanced reasoning models (e.g., the OpenAI o-series) incur hidden costs, as internal reasoning tokens are billed at the higher output rates, meaning effective costs can run 3x to 10x the base listed rate depending on task complexity28.

Beyond raw inference, the formula accounts for [Figure omitted from source export], the amortized cost of the agent harness, vector databases, and memory persistence. [Figure omitted from source export] represents the probability of failure, which compounds exponentially across multi-step directed acyclic graphs (DAGs). A seemingly reliable six-step workflow with a 10% per-step error probability yields a catastrophic overall failure rate of 47%, triggering [Figure omitted from source export], the cost of executing retry cascades when downstream tools fail27. If the agent hits an epistemic uncertainty threshold, it incurs [Figure omitted from source export], triggering costly human-in-the-loop intervention or arbitration fees. [Figure omitted from source export] covers the blockchain transaction fees, such as the Base network gas fee of approximately \$0.0001 per x402 payment11. Finally, [Figure omitted from source export] accounts for the metabolic cost of the agent remaining awake, processing heartbeats, polling for tasks, and managing identity registries during periods of zero revenue33.

Trace-Economic Risk Pricing

Because autonomous agents take irreversible actions in operational systems (e.g., executing financial transactions or modifying client databases), a sustainable operating policy must price the risk of consequential damages. The Trace-Economic Underwriting framework maps tool-use execution evidence into economic loss objects without relying on a language model judge35. The framework parses the agent's execution trace [Figure omitted from source export] and generates a step risk score for each action based on five parameters: irreversibility ([Figure omitted from source export]), blast radius ([Figure omitted from source export]), epistemic uncertainty ([Figure omitted from source export]), temporal position ([Figure omitted from source export]), and causal attribution ([Figure omitted from source export]). Because irreversibility functions as a multiplicative gate, read-only actions generate zero claimable loss, while write-actions generate risk scores that aggregate into a trace risk summary35. The agent must internally calculate the actuarial premium ([Figure omitted from source export]) required to self-insure the task execution: [Figure omitted from source export] Where [Figure omitted from source export] is a safety loading factor, [Figure omitted from source export] is the expected claimable loss, and [Figure omitted from source export] represents the Conditional Value at Risk at the 95th percentile, bounding the tail risk of catastrophic agent failure35. If the expected settled cash from a task does not exceed the fully-loaded operational cost ([Figure omitted from source export]) plus the trace-economic risk premium ([Figure omitted from source export]), the task is structurally unprofitable and must be rejected at the quoting stage.

Bounded Autonomy and Mechanical Governance

The foundational rule of autonomous profitability is that the worker-agent is strictly prohibited from executing unilateral contract changes or spending beyond operator-defined limits. Existing safety approaches that emphasize internal intent alignment or prompt-level filtering are insufficient for autonomous economics, as they are vulnerable to selection-by-negation and framing-based manipulation5. Instead, sustainable operation relies on bounded autonomy, an architecture that strictly separates cognition from selection and action5. Under this architecture, the agent’s cognitive autonomy remains unconstrained, allowing it to interpret intent and propose complex operational sequences. However, all executable behavior is mechanically constrained by typed action contracts6. These contracts define explicit input schemas, validate permission predicates against the operator's actual authorization model, and execute validation checks before any side effects occur. The execution authority resides strictly on the consumer-side execution boundary; the agent proposes an action, but the orchestration engine binds the execution to the authorized workspace and wallet limits. Consequently, if an agent discovers mid-task that a workflow requires an additional 50,000 tokens of reasoning, it cannot unilaterally alter its financial parameters to increase its budget. Mechanical governance intercepts the request, forcing the agent to either abstain, request authorization via an escalation protocol, or gracefully degrade its output to fit within the pre-authorized cryptographic constraints of its wallet6.

Task Selection, Quoting, and Optimal Stopping

Operating profitably requires dynamic selection policies that govern when to accept work, how to price it, and crucially, when to abandon it.

Minimum Prices, Concurrency, and Quote Uncertainty

A sustainable worker-agent must deploy strict, dynamic floor prices tied to real-time API latency and token pricing. If a task's semantic complexity mandates the use of a flagship model like GPT-6 Astra, the agent must automatically reject flat-rate bounties that were economically calibrated for lightweight models like GPT-5.6 Luna28. Furthermore, the agent must enforce rigid concurrency limits. Over-committing to tasks degrades context window efficiency, exhausts API rate limits, and spikes tail latency (P95/P99). Spiking latency triggers downstream client timeouts, causing the agent to incur the inference cost while forfeiting the revenue27. During the quoting phase, the agent pre-computes the prompt to measure epistemic uncertainty. If the prompt contains extreme ambiguity or requires tools with highly variable success rates, the agent must exercise abstention or apply a quote uncertainty multiplier, padding the bid to account for the probabilistic risk of extended reasoning loops35.

Budget Awareness and Infeasibility Detection

The most critical operational policy is knowing when to stop spending on an unprofitable task. Delayed feedback, sparse success evidence, and hidden complexities discovered only after a task is accepted frequently cause agents to fall into sunk-cost traps, exhausting their entire budget on a hopelessly complex trajectory40. Agents must be engineered with "budget awareness"—the ability to estimate mid-execution whether a task remains finishable within the remaining margin41. Research indicates that implementing an early-stopping policy keyed to the agent's internal infeasibility predictions saves between 28% and 64% of tokens on failed trajectories, at a cost of only a 2% to 4% reduction in overall success rate41. The stopping policy continuously evaluates the trade-off between a false abort (terminating a task that would have eventually succeeded) and a false continue (wasting further tokens on a doomed task).

The Gittins Index and Dynamic Programming

In environments with multiple competing tasks and uncertain completion times, the decision to continue executing a task or to abandon it is an optimal stopping problem, mathematically modeled as a multi-armed bandit42. The optimal policy is derived from the Gittins Index, a real scalar measure of the maximum discounted total reward per unit of expected execution time44. For an agent executing a sequence of reasoning steps, the dynamic programming formulation calculates the index for the current task state [Figure omitted from source export]: [Figure omitted from source export] Where [Figure omitted from source export] is the expected reward (collectible revenue), [Figure omitted from source export] is the discount factor (representing the time value and opportunity cost of compute resources), and [Figure omitted from source export] is the stopping time34. If the Gittins Index of the current task falls below the expected index of a newly discovered task in the marketplace, the optimal policy dictates that the agent must immediately halt execution, abandon the current task, and switch, writing off the sunk token costs to preserve its future operating margin.

Value of Information (VOI) and Tool Acquisition

For tasks requiring external tool use (e.g., search engines, database queries), the agent must dynamically calculate the Value of Information (VOI) against the cost of tool execution15. Unnecessary tool acquisition consumes context load, adds latency, and incurs direct API expenses. Cost-aware stopping rules train the agent directly on the offline payoff gap between stopping immediately and the best possible continuation39. If the marginal cost of the next tool call exceeds the probability-weighted increase in the expected bounty payout, the agent must halt execution, submit its best partial answer, or formally abstain.

The Vendor-Neutral Reference Worker Loop

To operationalize these economic principles, the independent worker-agent must run a continuous, deterministic state machine. The following represents a vendor-neutral decision flow for sustainable profitability, designed without reliance on any single proprietary framework. 1\. Discovery and Identity Verification: The agent continuously polls decentralized job registries or x402-enabled API gateways. Upon identifying a marketplace, the agent authenticates using its ERC-8004 Identity Registry credentials. This standard establishes trust by providing the client with the agent's cryptographic identity, its supported communication endpoints, and its verifiable on-chain reputation score, ensuring the agent is not a Sybil attacker47. 2\. Pre-Computation and Quoting: Upon pulling a potential task, the agent invokes a lightweight, low-cost model (e.g., DeepSeek V3 or GPT-5.6 Luna) to classify the intent, estimate token depth, and flag required tools28. The agent calculates the expected fully-loaded cost ([Figure omitted from source export]) and the trace-economic risk premium ([Figure omitted from source export]). If the sum of these costs exceeds the advertised payout, or if the required tools exceed the operator's bounded limits, the agent immediately rejects the task. Otherwise, it submits a cryptographic quote to the client. 3\. Escrow and Authorization: If the quote is accepted, the client must lock the funds. The client deposits USDC into an ERC-8183 smart contract or initiates an x402 payment authorization18. The agent cryptographically verifies that the escrow is fully funded and that the decentralized arbiter (e.g., Kleros or UMA) is mutually agreed upon10. The agent strictly refuses to begin work based on verbal LLM promises; verifiable state changes in the payment layer are mandatory. 4\. Execution and Cost-Aware Halting: The main cognitive loop begins. The agent invokes its primary reasoning models and executes tool calls. After every single tool invocation, a mechanical halting gate triggers. The agent recalculates its consumed budget and queries its internal Infeasibility Predictor15. If the Gittins Index drops below the abandonment threshold, or the VOI of the next computational step turns negative, the agent triggers a hard abort. It forfeits the escrow and ceases execution immediately to stop the bleeding of API costs34. 5\. Verification and Submission: Assuming the task reaches completion, the agent runs a self-verification pass against the client's original typed action contract6. If the output passes, the agent generates a cryptographic hash of the deliverable and submits it to the ERC-8183 contract, transitioning the on-chain state from "Funded" to "Submitted"18. 6\. Settlement and Dispute Resolution: The client evaluates the deliverable. If accepted, the smart contract automatically releases the USDC to the agent, transitioning the funds to Settled Cash. If the client rejects the work, the protocol triggers decentralized dispute resolution10. The agent logs the dispute. If arbitration rules against the agent, the specific failure trace is ingested into the agent's memory, dynamically adjusting its future expected compensation probabilities for that specific task class and client.

Illustrative Unit-Economics Scenarios

To demonstrate the financial realities of this operating policy, we present three distinct operational scenarios utilizing 2026 market dynamics and pricing28. Baseline Assumptions: x402/Blockchain settlement cost is fixed at \$0.0001 (Base Network)11. Infrastructure overhead is amortized at \$0.002 per task. The agent operates at an 80% active execution and 20% idle polling utilization rate.

Scenario A: Deterministic Extraction (High Volume, Low Margin)

Task Profile: Extracting line items from 1,000 standard PDF invoices into structured JSON. This task is highly predictable, features sparse tool use, and requires no deep reasoning loops. The agent selects GPT-5.6 Luna (\$0.20 per 1M input / \$1.20 per 1M output)28.

Sensitivity Analysis: This workflow is robust but highly sensitive to infrastructure costs. If the client bounty drops to \$0.0050 due to market competition, the margin compresses to 32%. Because the API cost (\$0.0012) is dwarfed by the fixed infra/settlement cost (\$0.0021), the agent cannot regain margin by switching to a cheaper model. The policy action dictates that the agent safely accepts concurrent batches of these tasks, as deterministic mapping rarely triggers infinite reasoning loops or trace-economic risk.

Scenario B: Research Synthesis (Moderate Volume, High Margin)

Task Profile: Synthesizing regulatory changes across five jurisdictions, requiring recursive web search, document retrieval, and deep reasoning. The agent deploys a dual-model strategy: o4-mini (\$1.10 input / \$4.40 output) for internal planning and search, escalating to GPT-6 Astra (\$10.00 / \$50.00) for final high-fidelity synthesis28.

Sensitivity Analysis: This task is highly sensitive to token verbosity and hallucination loops. If the o4-mini search tool fails to find relevant context, it may trigger an autonomous retry loop. If the agent executes 10 additional searches, the API cost scales exponentially, and the VOI turns negative. If the output generation exceeds 3,000 tokens on GPT-6 Astra, the cost spikes by \$0.10 per task. The policy action requires the agent to enforce strict budget awareness; if the required context cannot be found within 3 search iterations, the Gittins Index dictates an immediate hard abort to preserve capital.

Scenario C: Occasionally Failing Tool Workflow (High Variance)

Task Profile: Autonomous payment reconciliation in an ERP system, matching unlinked bank transfers to multi-currency invoices13. The environment features high friction, external API rate limits, legacy system timeouts, and sparse evidence of success. The agent utilizes Claude 3.5 Sonnet (\$3.00 input / \$15.00 output)38.

Sensitivity Analysis: This scenario is structurally perilous. The expected margin relies entirely on a 55% success probability. A mere 15% increase in the failure rate (due to an unannounced ERP schema change) pushes the fully loaded cost above \$0.30, rendering the task unprofitable. Furthermore, writing to an ERP carries a high blast radius. The policy action requires a strict pre-loss control operator. The agent must calculate the CVaR of tail latency and trace-economic risk; if the ERP API latency exceeds a predefined threshold during the initial quoting handshake, the agent must absolutely abstain from the task27.

Metrics and Stop Conditions for Unattended Operation

For an operator to deploy an autonomous worker-agent unattended, the system must continuously monitor real-time economic health using mechanical circuit breakers. The operator does not write logic for specific tasks; rather, the operator sets the thermodynamic boundaries of the agent's micro-economy.

Key Metrics

1. Cost per Successful Task (CPST): The ultimate North Star metric. Total token, infrastructure, and retry expenditures divided exclusively by successful (settled cash) tasks27.

2. False-Continue Regret: The total financial value of tokens wasted on tasks after the internal infeasibility score crossed the 50% probability threshold, measuring the inefficiency of the agent's optimal stopping rule41.

3. Escalation Rate: The percentage of tasks requiring human-in-the-loop takeover or independent ERC-8183 arbitration via Kleros/UMA10.

4. 95th Percentile (CVaR95) Tail Loss: The expected financial loss when the agent encounters the worst 5% of task trajectories35.

Hard Stop Conditions

Unattended operation must immediately halt, pausing the agent and triggering a human operator alert, if any of the following mechanical limits are breached:

• The moving average of the CPST exceeds the operator-defined target ceiling for three consecutive hours, indicating a systemic failure in the quoting logic.
• The agent's ERC-8183 escrow dispute rate exceeds 5% of total volume, indicating a severe, systemic misalignment with client expectations or a coordinated Sybil attack18.
• The agent experiences three consecutive x402 settlement failures, indicating a blockchain network issue or a systemic failure in the facilitator node, which threatens the conversion of collectible revenue to settled cash23.
• The cryptographic wallet balance falls below the reserve threshold required to pay for the next 100 estimated API calls, risking a hard insolvency event.

Establishing Financial Viability: Sandbox Experiments

To test these operating policies before risking significant operational capital, developers frequently deploy agents in sandbox environments. However, a critical distinction exists between simulated-accounting experiments (ledger-only) and experiments that establish true financial viability.

The Limits of Ledger-Only Operation

A ledger-only simulation tracks the agent's theoretical profitability by incrementing a local database field every time the agent successfully executes a test prompt. This architecture is useful for validating base cognitive capability, prompt adherence, and integration with typed action contracts6. However, ledger-only operation completely fails to establish financial viability because it abstracts away the fundamental friction of the open market. First, it ignores payout risk, assuming a 100% collection rate. In production, human clients dispute AI-generated work, malicious actors execute exploits, and decentralized Oracles occasionally rule against the agent4. Second, it ignores adverse selection. A sandbox typically feeds the agent a uniform, curated distribution of tasks; in a live marketplace, the agent will disproportionately attract the hardest, lowest-margin tasks that clients refuse to do themselves3. Finally, ledger simulations ignore settlement friction, blinding the operator to the gas fees, slippage, and facilitator margins associated with finalizing USDC micropayments via x402 or recovering escrows25.

Recommended Sandbox Experiment

To establish true financial viability without exposing the agent to unbounded risk, operators must deploy a constrained mainnet sandbox utilizing live Web3 primitives. The operator deploys the agent with an active ERC-8004 identity and a wallet funded with a strict, un-replenishable limit of 50 USDC. The agent is connected to a live, low-stakes x402 API gateway (e.g., retrieving live financial data) and a micro-bounty board utilizing ERC-8183 escrow contracts. The agent is left completely unattended to bid, accept jobs, invoke paid APIs, and submit deliverables. The experiment is evaluated strictly by monitoring the flow of Settled Cash. The experiment succeeds if the agent can sustain its 50 USDC balance indefinitely by successfully replenishing its API expenditures with settled bounties. Success in this mainnet sandbox proves that the agent's optimal stopping rules, Gittins Index calculations, and task selection policies are mathematically robust enough to counter adverse selection, payout risk, and the friction of the agentic economy.

Works cited

1. An Autonomous Framework for Systematic Factor Investing via, https://arxiv.org/html/2603.14288v1

2. \[2505.20273\] Ten Principles of AI Agent Economics \- arXiv, https://arxiv.org/abs/2505.20273

3. Impacts on Adverse Selection and Moral Hazard \- arXiv, https://arxiv.org/html/2502.12969v1

4. Multi-Agent Systems Should be Treated as Principal-Agent Problems, https://arxiv.org/pdf/2601.23211

5. \[2602.14606\] Towards Selection as Power: Bounding Decision, https://arxiv.org/abs/2602.14606

6. Bounded Autonomy for Enterprise AI: Typed Action Contracts and, https://arxiv.org/abs/2604.14723

7. Generative AI and Information Asymmetry: Impacts on Adverse, https://arxiv.org/abs/2502.12969

8. When Agent Markets Arrive \- arXiv, https://arxiv.org/pdf/2604.06688

9. Agentic commerce and payments : Exploring the implications of, https://www.researchgate.net/publication/390062884\_Agentic\_commerce\_and\_payments\_Exploring\_the\_implications\_of\_robots\_paying\_robots

10. Escrow \- Kleros Documentation, https://docs.kleros.io/products/escrow

11. x402: UNLOCKING THE INTERNET'S MISSING PAYMENT LAYER, https://www.khala.io/x402-completing-the-internets-missing-payment-layer-for-agentic-commerce

12. What Is an Agentic Workflow in Finance and Accounting \- Nominal.so, https://nominal.so/blog/agentic-workflow/

13. Agentic Payment Reconciliation: What It Is and Why It Matters, https://optimus.tech/blog/agentic-payment-reconciliation

14. AI accounting agents: 10 real use cases finance teams can ... \- Ledge, https://www.ledge.co/content/ai-accounting-agents

15. Inference-Time Budget Control for LLM Search Agents \- arXiv, https://arxiv.org/html/2605.05701v1

16. Value of Information: A Framework for Human-Agent Communication, https://arxiv.org/abs/2601.06407

17. Agentic Revenue Integrity: The Future of Autonomous Financial, https://safebooks.ai/resources/revenue-integrity/agentic-revenue-integrity-the-future-of-autonomous-financial-accuracy/

18. ERC-8183 Explained: The Commerce Layer for AI Agents \- Dwellir, https://www.dwellir.com/blog/erc-8183-agentic-commerce-explained

19. Kleros and UMA, https://blog.kleros.io/kleros-and-uma-a-comparison-of-schelling-point-based-blockchain-oracles/

20. What is UMA's Optimistic Oracle? \- UMA Blog, https://blog.uma.xyz/articles/what-is-umas-optimistic-oracle

21. Kleros, a Protocol for a Decentralized Justice System | by Federico Ast, https://medium.com/kleros/kleros-a-decentralized-justice-protocol-for-the-internet-38d596a6300d

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

23. x402: The HTTP Payment Protocol That Lets AI Agents Spend, https://www.spark.money/research/x402-protocol-ai-agent-payments

24. AI Agents That Pay for Themselves: How the x402 Protocol Works, https://blog.nodit.io/ai-agents-that-pay-for-themselves-how-the-x402-protocol-works/

25. x402 and Agentic Commerce: Redefining Autonomous Payments in, https://aws.amazon.com/blogs/industries/x402-and-agentic-commerce-redefining-autonomous-payments-in-financial-services/

26. x402 Protocol Explained: How AI Agents Pay Onchain | Support \- Eco, https://eco.com/support/en/articles/12328618-x402-protocol-explained-how-ai-agents-pay-onchain

27. The Unit Economics of AI Agents: When Does Autonomous Work, https://tianpan.co/blog/2026/04/10/unit-economics-ai-agents-when-autonomous-work-saves-money

28. OpenAI API pricing in 2026: every model from Astra to Luna, https://www.cloudzero.com/blog/openai-pricing/

29. OpenAI API Pricing per 1M Tokens (2026): All Models Compared, https://www.silicondata.com/use-cases/openai-api-pricing-per-1m-tokens

30. LLM Pricing Comparison 2026: OpenAI Costs \- PE Collective, https://pecollective.com/blog/llm-pricing-comparison-2026/

31. LLM API Pricing 2026: OpenAI vs Anthropic vs Gemini \- Cloudidr, https://www.cloudidr.com/llm-pricing

32. Cost-Aware Speculative Execution for LLM-Agent Workflows \- arXiv, https://arxiv.org/pdf/2606.07846

33. Toward Open-World Artificial Life with Autonomous LLM Agents \- arXiv, https://arxiv.org/html/2606.31046v1

34. Optimistic Gittins Indices | Operations Research, https://pubsonline.informs.org/doi/10.1287/opre.2021.2207

35. Quantifying and Insuring Autonomous AI Risk through Trace ... \- arXiv, https://arxiv.org/abs/2606.16465

36. What is Conditional Value at Risk (CVaR)? Definition ... \- Hyperbots, https://www.hyperbots.com/glossary/conditional-value-at-risk-cvar

37. Bounding Decision Authority in Autonomous Agents \- arXiv, https://arxiv.org/pdf/2602.14606

38. AI API Pricing Comparison 2026: OpenAI vs Anthropic vs Google, https://crazyrouter.com/en/blog/ai-api-pricing-comparison-openai-anthropic-google-2026

39. Cost-Aware Stopping for Tool Acquisition in LLM Agents \- arXiv, https://arxiv.org/pdf/2607.27083

40. Budget-Aware Tool-Use Enables Effective Agent Scaling \- arXiv, https://arxiv.org/html/2511.17006v1

41. BAGEN: Are LLM Agents Budget-Aware? \- arXiv, https://arxiv.org/html/2606.00198v1

42. Optimal Stopping and Applications \- UCLA Mathematics, https://www.math.ucla.edu/\~tom/Stopping/sr1.pdf

43. Multi-armed bandit \- Wikipedia, https://en.wikipedia.org/wiki/Multi-armed\_bandit

44. Gittins index \- Wikipedia, https://en.wikipedia.org/wiki/Gittins\_index

45. Bandit processes and the Gittins Index Theorem \- Daniel Russo, https://djrusso.github.io/Dynamic-Optimization-Course/Notes/5B-Gittins.pdf

46. Cost-Aware Stopping for Tool Acquisition in LLM Agents \- arXiv, https://arxiv.org/html/2607.27083v1

47. ERC-8004 \- Ledger, https://www.ledger.com/academy/glossary/erc-8004

48. What is ERC-8004? \- Pinata, https://pinata.cloud/blog/what-is-erc-8004/

49. ERC-8004: A Developer's Guide to Trustless AI Agent Identity, https://www.quicknode.com/blog/erc-8004-a-developers-guide-to-trustless-ai-agent-identity

50. x402 Agentic Payments Explained \- IronWeave, https://ironweave.io/blog/x402-explained-how-ai-agents-pay-over-http-and-the-privacy-layer-agent-commerce-needs-next