The rapid proliferation of autonomous AI agents operating in blockchain environments has created an unaddressed systemic risk. These agents — executing trades, managing liquidity, processing payments, and handling sensitive data on behalf of human principals — collectively control billions of dollars in assets across leading high-performance chains. Yet no dedicated insurance infrastructure covers them. When agents fail, are exploited, or breach data obligations, their operators bear the entire loss with no mechanism for recovery.
Regore is a decentralised risk-sharing protocol that fills this gap. By combining parametric trigger logic, battle-tested oracle infrastructure, and a transparent on-chain reserve pool, Regore delivers the first AI-agent-native insurance products designed for high-throughput blockchain ecosystems. Three coverage lines address the most material risks operators face:
Regore operates as a decentralised autonomous mutual — modelled on the legal and operational structure validated by Nexus Mutual — requiring no insurance licence and governed by its community of token holders. Premiums are priced algorithmically based on each agent's on-chain risk profile. Reserve capital is pooled, deployed into low-risk DeFi yield strategies, and backstopped by a reinsurance arrangement for large individual claims. Liquidity providers earn risk-adjusted returns of 8–14% APY.
Regore is raising a seed round to fund smart-contract development, security auditing, oracle integration, and the onboarding of design-partner operators for a controlled mainnet launch.
The combination of sub-second finality, near-zero transaction costs, and a rich ecosystem of DeFi primitives across leading high-performance chains has made these networks the preferred environment for high-frequency, programmatic activity. AI agents — software systems that autonomously execute actions in pursuit of defined objectives — have become significant participants. They arbitrage price discrepancies across decentralised exchanges, rebalance lending positions, process micro-payments on behalf of users, and increasingly manage sensitive personal and financial data.
By early 2026, total value locked across major DeFi ecosystems exceeded tens of billions of dollars. Industry analysts estimate that autonomous agents — including algorithmic trading bots, AI-powered portfolio managers, and automated payment rails — account for a growing share of on-chain transaction volume. The global market for AI-agent transaction infrastructure is projected to reach $40 billion by the end of 2026.
Despite their scale and sophistication, AI agents are categorically uninsured. Three data points illustrate the severity of this gap:
| Metric | Current State | Implication for Operators |
|---|---|---|
| DeFi exploit losses (2025) | $3.4 billion | Zero covered by insurance products |
| DeFi TVL insured globally | < 0.5% of total | AI agents: no dedicated products exist |
| High-performance chain DeFi TVL (Q1 2026) | Tens of billions | Entirely uncovered by any protocol |
Existing DeFi insurance protocols — including Nexus Mutual, InsurAce, and Unslashed Finance — are structurally mismatched for AI-agent use cases. They are designed primarily for Ethereum smart-contract risk, require manual claim filing and adjudication, and offer no per-transaction coverage mechanism. None are deployed on Solana. Armilla AI has pioneered enterprise AI liability coverage, but their product targets corporate clients via traditional insurance channels, not on-chain agent operators that require real-time, automated settlement.
Through research and operator interviews, Regore has identified three primary categories of loss event that AI agent operators consistently cite as material concerns:
An agent's wallet is drained through exploitation of a smart-contract vulnerability, a flash-loan attack on a protocol it is interacting with, or a configuration error that causes runaway adverse trading. The operator loses the capital under management with no recourse. This category is particularly severe because agents often operate with positions that significantly exceed the value of the underlying protocol's treasury.
High-frequency agents are systematically exposed to the delta between the price at which an order is submitted and the price at which it executes — a gap caused by block-time latency, network congestion, or MEV extraction. While individual slippage events may be small, they compound across thousands of trades per session and can render otherwise profitable strategies uneconomic. No existing product insures individual transaction execution.
AI agents increasingly handle sensitive data: user wallet addresses, trading strategies, personally identifiable information, and proprietary model weights. A breach — whether through a compromised API key, an insecure storage mechanism, or a man-in-the-middle attack on an agent's communication channel — can expose operators to regulatory liability (particularly under emerging AI-accountability frameworks) and reputational damage that existing indemnity products do not cover in the decentralised context.
"When an agent is hacked or leaks data, the operator loses everything. There is no call centre, no adjuster, no policy. Just loss."
This absence of a coverage layer is not merely a commercial inconvenience: it constitutes a systemic vulnerability that suppresses the legitimate growth of AI-agent infrastructure. Operators who would otherwise deploy capital at scale are constrained by tail-risk exposure they cannot hedge.
Regore is built on four first principles derived from the failure modes of existing DeFi insurance products:
Financial Loss Coverage protects AI agent operators against material wallet depletion events. At policy inception, the operator registers their agent's primary wallet address and selects a loss threshold expressed as a percentage of the insured balance (minimum 10%, maximum 50%). They lock a 10% co-insurance deposit into an escrow account.
A wallet-monitoring oracle observes the wallet balance at 60-second intervals throughout the policy period. When the reported balance falls below the threshold, an independent price feed is used to compute the USD-denominated loss at the moment of breach. The protocol's smart contract automatically transfers the lesser of the computed loss amount or the policy maximum ($30,000) in USDC to the operator's registered wallet. No claim filing is required.
| Parameter | Specification |
|---|---|
| Maximum payout | $30,000 USDC per session |
| Premium | Risk-adjusted; contact for current rates |
| Co-insurance deposit | 10% of coverage limit, returned on cancellation |
| Waiting period | 30 days from policy inception (fraud protection) |
| Oracle stack | Wallet-monitoring oracle + decentralised price feed |
| Settlement | Automatic, within one oracle cycle (~60 seconds) |
| Payout cap (first 90 days) | 50% of computed loss (fraud suppression period) |
Per-Trade Cover insures individual on-chain transactions against adverse price movement between order submission and execution. This product is designed for high-frequency trading agents, market-making bots, and arbitrage strategies where per-transaction slippage is a material operating cost.
When the agent submits a transaction, the Regore co-processor records the oracle-reported price of the relevant asset at submission time. After confirmation, the co-processor computes the execution price from the transaction's instruction data. If the negative delta — expressed as (submission price − execution price) / submission price — exceeds the operator's configured threshold, a payout is triggered. A small per-transaction micro-premium is deducted from the operator's pre-funded USDC deposit for each covered transaction, regardless of whether a payout occurs.
| Parameter | Specification |
|---|---|
| Maximum payout | $5,000 USDC per transaction |
| Premium | Per-transaction micro-premium; contact for current rates |
| Threshold range | 0.5%–5.0% slippage (operator-configured) |
| Waiting period | None; active on first transaction |
| Oracle | Decentralised price feeds (submission and execution) |
| Settlement | Automatic, within one block |
Data Breach Indemnity covers losses arising from the unauthorised disclosure, exfiltration, or misuse of data handled by a registered AI agent. At policy inception, the operator submits a SHA-256 hash of their agent's execution logs for the prior 30 days — a requirement that establishes a cryptographic baseline of the agent's normal operational footprint and serves as the ground truth for breach verification.
When a data breach occurs, the operator submits a claim package comprising: the incident timestamp, a description of the breach mechanism, a signed assertion of loss amount, and execution logs sufficient to demonstrate the breach event. Five reviewers, selected randomly from Regore's staked reviewer registry, are allocated the claim. Reviewers earn a review fee if their vote aligns with the majority outcome; reviewers in the minority forfeit a portion of their stake. A 3-of-5 supermajority is required for claim approval. If approved, USDC up to the policy maximum ($30,000) transfers to the operator within 72 hours of claim submission.
| Parameter | Specification |
|---|---|
| Maximum payout | $30,000 USDC per incident |
| Premium | Risk-adjusted; contact for current rates |
| Co-insurance deposit | 10% of coverage limit |
| Proof of operation | 30 days of signed log hashes required at inception |
| Review panel | 5 staked reviewers, randomly selected; 3-of-5 approval |
| Settlement | Within 72 hours of claim submission |
| Scope | PII, financial data, proprietary models, API credentials |
Regore is implemented as a set of programs deployed on Solana using the Anchor framework. The core programmes are:
All programmes are formally verified against a specification that constrains state transitions to prevent reentrancy, integer overflow, and unauthorised fund access. The codebase will be audited by a reputable security firm prior to mainnet deployment.
Regore's oracle architecture is deliberately layered, with each layer designed to handle a specific category of information and provide a distinct set of security guarantees:
A pair of decentralised oracle networks provides real-time price feeds and configurable off-chain data feeds (including wallet balance polling and custom computation tasks). For Financial Loss Coverage and Per-Trade Cover, these feeds serve as the sole source of truth: if the data says a loss occurred, the payout executes. No human discretion is applied. This layer handles approximately 95% of expected claims by volume.
For Data Breach Indemnity — where the loss event is a real-world occurrence that cannot be directly observed on-chain — Regore implements a reviewer panel modelled on UMA Protocol's optimistic oracle and the Nexus Mutual claim-assessment framework. Reviewers must stake a minimum of 1,000 REGR tokens to join the registry. For each claim, five reviewers are selected using a verifiable random function (VRF) seeded by the claim transaction hash.
Reviewer incentives are structured to produce honest outcomes: the expected return from voting truthfully (earning the review fee plus stake preservation) exceeds the expected return from colluding with a fraudulent claimant (earning a share of the fraudulent payout minus stake forfeiture risk). This property holds as long as the proportion of dishonest reviewers remains below 40%, which the staking requirement and slashing mechanism are calibrated to achieve.
Any party — claimant, reviewer, or liquidity provider — may escalate a disputed data-breach claim to the protocol's DAO governance layer, implemented via the Governance Programme. Disputed claims are put to a token-weighted vote among all REGR holders, with a seven-day deliberation period. This layer serves as the final backstop for edge cases that the reviewer panel mechanism cannot definitively resolve.
Premium pricing is computed on-chain at policy inception using a base rate multiplied by four risk factors derived from the agent's on-chain history and declared operational parameters:
The Capital Multiplier scales with the ratio of capital under management to the operator's historical average, penalising sudden leverage increases. The Data Sensitivity Factor reflects the classification of data the agent handles (from 1.0× for public data to 2.5× for regulated PII). The Autonomy Level Factor reflects the degree of human oversight in the agent's decision loop (from 1.0× for supervised agents to 1.8× for fully autonomous agents). All factors are declared by the operator and verified against on-chain evidence where available; misrepresentation voids coverage.
The Regore reserve pool is structured to ensure solvency under realistic stress scenarios while providing competitive returns to liquidity providers. At launch, the protocol targets a coverage-to-reserve ratio of 1.5:1 — meaning aggregate coverage limits outstanding will not exceed 150% of the reserve pool's USDC balance. This ratio is enforced programmatically: new policy issuance is paused if the ratio would be breached.
A minimum surplus fund of 15% of total premiums is retained before any distributions are made to liquidity providers. This fund accumulates over time and provides a first-loss buffer ahead of the general reserve pool.
Regore's fraud suppression stack combines four independent mechanisms, each targeting a different attack vector:
Claims exceeding $20,000 on any individual policy are eligible for reinsurance recovery under an arrangement under negotiation with a leading decentralised reinsurance protocol. Reinsurance participation provides a capital backstop that allows Regore to offer coverage limits that would otherwise be imprudent relative to the reserve pool size at launch. The reinsurance premium is treated as a protocol operating expense, borne by the protocol surplus fund rather than passed directly to policyholders.
Idle reserve capital not required to satisfy near-term claim obligations is deployed into vetted DeFi lending markets, generating a base yield of approximately 4–6% APY. This yield supplements the premium income distributed to liquidity providers, improving their effective return without increasing policyholder costs. The protocol governance defines a maximum deployment cap — initially 40% of the reserve pool — to ensure sufficient liquidity for immediate claim settlement.
REGR is the native governance and utility token of the Regore protocol. Its functions are:
REGR has a fixed total supply of 100,000,000 tokens. It is not launched at protocol inception; the token launch is scheduled for a future milestone, after the protocol has demonstrated sustainable premium revenue and a loss ratio within the modelled range. This sequencing avoids the governance capture and speculative dynamics that have undermined other DeFi insurance protocols that launched tokens before establishing product-market fit.
Gross premium revenue is distributed in the following waterfall:
| Destination | Allocation |
|---|---|
| Protocol surplus fund (first-loss buffer) | 15% of gross premiums |
| Reinsurance premium | ~5% of gross premiums (claims > $20K) |
| Liquidity provider yield pool | Pro-rata share of remaining premiums after costs |
| Reviewer fees (Data Breach product only) | 0.5% of covered Data Breach premiums per claim |
| Protocol treasury (development, audits) | 5% of gross premiums |
Liquidity providers deposit USDC into the Regore reserve pool. Their capital is at risk in the event of claims exceeding premium income and the surplus fund. In exchange, they receive a pro-rata share of net premium income after the protocol surplus allocation and operating expenses, a pro-rata share of yield generated by the deployed reserve capital, and REGR token boost allocations proportional to their staked REGR balance (post-token launch).
Under the base-case model (loss ratio: 60%, blended premium consistent with risk-adjusted pricing, reserve deployment yield: 5%), the projected LP return is 11.4% APY. Liquidity providers are subject to a seven-day unbonding period before withdrawal, which prevents liquidity runs in the immediate aftermath of a large claim event.
Regore's addressable market sits at the intersection of three converging trends: the growth of AI-agent infrastructure, the expansion of DeFi on high-performance chains, and the emergence of regulatory frameworks that impose liability on AI operators. The TAM is estimated as follows:
| Market Segment | 2026 Estimate | Regore Relevance |
|---|---|---|
| AI-agent transaction volume (DeFi + payments) | $40B+ | Per-trade and financial-loss products |
| High-performance chain DeFi TVL | Tens of billions | Financial-loss exposure for active agents |
| DeFi insurance TVL (global) | $1.7B (growing to $5–8B) | Reserve capital and product design benchmarks |
| Enterprise AI deployment spend (global) | $150B+ | Data breach indemnity product |
No existing protocol directly competes with Regore's combined value proposition. The competitive landscape can be segmented into the following:
| Protocol | Coverage Type | Multi-chain? | Per-Trade? | AI Agent-Native? |
|---|---|---|---|---|
| Nexus Mutual | Smart-contract risk | Limited | No | No |
| InsurAce | Protocol coverage | Limited | No | No |
| Unslashed Finance | DeFi coverage | Limited | No | No |
| Armilla AI | AI liability | Off-chain | No | Partial (enterprise) |
| Regore | AI agent-native | Yes | Yes | Yes (full) |
Regore's structural advantages are: (1) first-mover for any AI-agent insurance product on high-performance chains; (2) the only protocol offering per-trade parametric coverage; (3) native integration with the oracle infrastructure already trusted by the protocols Regore's policyholders interact with; and (4) a product design that explicitly optimises for the operational requirements of autonomous agents rather than adapting a human-centric insurance model.
Regore has completed the following milestones prior to its seed raise:
Regore conducted structured interviews with ten AI-agent operators across three categories: DeFi trading bots (four), data-processing agents (three), and payment automation agents (three). Key findings:
The market infrastructure for Regore's product is maturing rapidly. In March 2026, Aon — one of the world's largest insurance brokers — completed the first on-chain insurance premium settlement on Solana. Armilla AI secured Lloyd's of London backing for the first AI model liability policy in April 2025. These developments signal that institutional capital and traditional risk-transfer markets are actively seeking exposure to AI insurance risk — a validation of the category that Regore is designed to serve natively.
Three DeFi treasury teams have engaged in preliminary conversations about participating as liquidity providers in the Regore reserve pool at the target return of 11.4% APY. One investment fund focused on on-chain risk infrastructure has expressed interest in committing capital at protocol launch, subject to completion of the security audit and mainnet deployment.
The controlled launch phase prioritises quality over quantity. Regore will onboard a maximum of ten design-partner operators recruited from the customer-discovery process. These operators receive subsidised premiums in exchange for committing to provide detailed operational feedback, participate in the reviewer registry with their technical staff, and serve as public references for the protocol. The design-partner programme allows Regore to validate the claim-trigger logic, pricing model, and reviewer-incentive structure against real-world loss events before opening the protocol to permissionless access.
Target metrics at end of Phase 1: $500,000 USDC in reserve pool TVL; ten active policies; zero unresolved disputed claims; loss ratio within modelled range (55–65%).
Phase 2 opens the protocol to permissionless policy purchase and LP participation. The Data Breach Indemnity product is launched, and the reviewer registry is opened to any REGR staker meeting the minimum stake threshold. Regore pursues integrations with the major DeFi protocols whose users are most likely to be operating AI agents: DEX aggregators, MEV infrastructure, perpetuals venues, and NFT automation platforms. A B2B API is launched that allows AI-agent platforms and agent-building frameworks to embed Regore coverage as a native feature of their products.
Target metrics at end of Phase 2: $5,000,000 USDC in reserve pool TVL; 200 active policies; 50 active reviewer stakers; loss ratio within modelled range.
Phase 3 deepens Regore's Solana integration — expanding oracle coverage, adding Solana-native yield strategies for the reserve pool, and launching the REGR governance token. An enterprise licensing programme is introduced for companies deploying AI agents that require on-chain-verifiable insurance indemnity for regulatory compliance.
Target metrics at end of Phase 3: $50,000,000 USDC in reserve pool TVL; 2,000 active policies on Solana; REGR governance fully active.
The following projections are based on base-case assumptions: blended monthly premium consistent with risk-adjusted pricing, 60% loss ratio, and reserve deployment yield of 5% APY. These assumptions are conservative relative to comparable DeFi insurance protocols.
| Period | Active Policies | Reserve TVL | Annual Revenue |
|---|---|---|---|
| Launch | 10 | $500K | $8,500 |
| +3 months | 40 | $1.5M | $28,000 |
| +6 months | 100 | $3M | $72,000 |
| +12 months | 200+ | $5M+ | $210,000+ |
| +24 months | 2,000+ | $50M+ | $2.1M+ |
The seed round will be allocated as follows:
| Category | % of Round |
|---|---|
| Engineering (smart contracts, oracle integration, security audit) | 40% |
| Reserve pool seeding (initial LP capital) | 25% |
| Business development and ecosystem relationships | 20% |
| Operations, legal structure, and compliance | 15% |
| Total | 100% |
Regore was founded by a team with deep expertise in AI-agent infrastructure, DeFi protocol design, and product strategy. The founding team has built and shipped full-stack Web3 products from inception to deployment, with experience spanning financial advisory, product management, and blockchain development.
Regore is actively recruiting for two critical roles:
Regore is seeking advisors from organisations including Nexus Mutual, leading reinsurance protocols, major oracle networks, Armilla AI, and prominent AI-agent protocols. Introductions to qualified candidates for open roles are welcomed.
Regore is structured as a decentralised risk-sharing mutual, not as a licensed insurance company. This structure — pioneered by Nexus Mutual and validated through several years of operation and regulatory scrutiny — does not require the protocol to hold an insurance licence in most jurisdictions because coverage is provided through a discretionary mutual rather than a regulated insurance contract. Members of the mutual purchase cover from a shared pool of capital contributed by other members and LP participants.
This structure is legally distinct from insurance in several important respects: coverage is discretionary (the protocol's smart contracts determine outcomes algorithmically rather than through contractual obligation), membership is open to any person meeting the registration criteria, and the mutual is governed by its token-holding members rather than by corporate directors. Regore's legal counsel is reviewing the applicability of this structure under relevant jurisdictions, with a focus on Singapore, the British Virgin Islands, and the Cayman Islands as potential domiciles for the protocol's legal entity.
Regore does not offer licensed insurance products. Coverage provided by the Regore protocol is discretionary mutual coverage, not an insurance contract. Policyholders should be aware that the protocol's smart contracts, while subject to rigorous security auditing, may contain undiscovered vulnerabilities. Past performance of DeFi insurance protocols does not guarantee future performance of Regore. The REGR token is a utility and governance token and is not offered as a security or investment.
The autonomous AI agent is the defining new participant in decentralised finance. These agents now control billions of dollars in assets, execute millions of transactions, and handle sensitive data at a scale and speed that no human operator can match. Yet they remain categorically uninsured — a gap that suppresses the legitimate deployment of capital, exposes operators to unhedgeable tail risk, and creates systemic fragility in an ecosystem that is otherwise rapidly maturing.
Regore addresses this gap with a precision-engineered, chain-native parametric insurance protocol. By combining decentralised oracle infrastructure with a rigorous staked-reviewer mechanism for non-parametric claims, Regore delivers coverage that settles in seconds for parametric events and within 72 hours for data-breach incidents — without brokers, adjusters, or paper forms.
The market opportunity is large, the competitive field is empty, and the technical infrastructure to build this product now exists on Solana. Regore is building the insurance layer that autonomous AI agents require and that the ecosystem urgently needs.
"No AI agent should operate without coverage. Regore is building the infrastructure to make that the default."
Regore is the on-chain coverage layer for AI agents that move capital. Three parametric products — financial loss, per-transaction slippage, and data breach — engineered for oracle-verified, USDC-denominated settlement on Solana.
No intermediaries. No manual review for parametric triggers. No counterparty risk. The same on-chain infrastructure that settles DeFi trades settles your coverage.
Every policy is priced on a transparent, on-chain risk score derived from the agent's behavior. When a claim is filed, it is routed to a three-agent DAO tribunal — each agent reasoning from a distinct lens — that reaches a verdict before any payout is approved.
Premiums are not flat-rated. At policy inception, each agent receives a risk score computed on-chain from a weighted blend of behavioral and structural inputs. The score determines pricing, coverage limits, and any required co-insurance — and updates as new on-chain evidence accumulates.
Each agent evaluates the claim through a different lens — moral reasoning, ethical accountability, and quantitative risk. A consensus across all three lenses must be reached before stablecoin is released from the reserve pool.
Evaluates the claim against the foundational logic of the protocol: was the loss event genuinely covered? Does the operator's evidence align with the spirit of the policy, not just its literal terms? Surfaces edge cases that a strict-rule check would miss.
Audits the moral weight of the claim: was the agent operated responsibly? Are there third parties harmed by the loss event whose interests must be considered? Detects potential moral hazard, bad-faith claims, and externalities the protocol must price in.
Plays the traditional insurance adjuster role with on-chain rigor: validates the loss against oracle data, computes appropriate payout sizing within policy limits, models the impact on reserve solvency, and confirms the claim is consistent with the agent's risk score at inception.
For data breach claims, evidence is submitted here and routed to the three-agent DAO tribunal. Financial loss and per-trade payouts trigger automatically — no filing required.
| Agent ID | — |
| Wallet | — |
| Submitted by | — |
| Type | — |
| Amount | — |
| Incident | — |
| Description | — |
| Evidence | — |
// Payload updates as you type // POST /api/v1/claims { "agent_id": null, "claim_type": null, "amount_claimed": null, "description": null, "submitted_by": null, "evidence": [] }
Premiums are designed to be computed on-chain from each agent's risk profile — autonomy level, capital under management, and on-chain behavior. Pricing is tailored to each design partner; reach out to discuss coverage that fits your operation.
Common questions about the protocol, coverage triggers, payout mechanics, and LP participation. For anything not covered here, reach out directly.
[email protected] →Regore is pre-launch. If you're operating autonomous agents on-chain — or building the infrastructure they rely on — we'd like to talk. Design partners help shape the protocol before mainnet.