Liability Market

chio-market is the registry and workflow for liability coverage in the agent economy. Carriers, surplus lines, captives, and risk pools publish jurisdiction-scoped policies; operators request quotes against those policies; and a successful bind produces a signed coverage artifact that a downstream claim can be filed against. This page describes the types in chio-market and the quote-and-bind helper in chio-market::insurance_flow.

Provider Types

LiabilityProviderType tags each registered provider with one of four kinds. The chio types are named after their analogues in real insurance markets:

Provider lifecycle uses LiabilityProviderLifecycleState: Active, Suspended, Superseded, Retired. The default registry is curated; see LiabilityProviderSupportBoundary for the support flags.

Coverage Classes

LiabilityCoverageClass organizes coverage into five classes:

Jurisdiction Policies

Coverage is always scoped to a jurisdiction. Each provider publishes one or more LiabilityJurisdictionPolicy records, one per jurisdiction. Duplicate jurisdictions on a single provider are rejected at validation time.

pub struct LiabilityJurisdictionPolicy {
    pub jurisdiction: String,                                  // e.g. "us-ny"
    pub coverage_classes: Vec<LiabilityCoverageClass>,
    pub supported_currencies: Vec<String>,                     // ISO 4217, uppercase
    pub required_evidence: Vec<LiabilityEvidenceRequirement>,
    pub max_coverage_amount: Option<MonetaryAmount>,
    pub claims_supported: bool,
    pub quote_ttl_seconds: u64,
    pub notes: Option<String>,
}

Validation enforces that:

• At least one coverage class is listed.
• At least one supported currency is listed, each a three-letter uppercase ISO-style code.
• quote_ttl_seconds is greater than zero.
• When max_coverage_amount is set, its currency matches one of the supported currencies.

Evidence Requirements

LiabilityEvidenceRequirement lists the artifact kinds a provider expects with each quote request. Seven requirements ship today:

Required evidence is enumerated on the policy; it is the operator's responsibility to assemble the right artifacts before submitting a quote request. Missing or stale evidence is the most common reason a quote request is declined or sent to manual review.

Quote-and-Bind Workflow

Two surfaces ship for binding coverage. The artifact-shaped path is provider-facing and produces signed records at every step. The function-shaped quote_and_bind helper is the compact API used inside chio-kernel.

Artifact Workflow

1. Quote request: LiabilityQuoteRequestArtifact references a LiabilityProviderPolicyReference, a requested coverage amount, an effective window, and a signed CreditProviderRiskPackage. Validation checks the risk package signature and that the requested amount stays within the provider's max coverage.
2. Quote response: LiabilityQuoteResponseArtifact carries either LiabilityQuoteDisposition::Quoted (with LiabilityQuoteTerms: coverage amount, premium amount, optional deductible, expires_at) or Declined (with a decline reason). Quote terms expire by expires_at, which cannot exceed the provider policy's quote_ttl_seconds.
3. Pricing authority: LiabilityPricingAuthorityArtifact binds together the quote request, an active granted facility, an active approved underwriting decision, and a capital book. It caps the coverage and premium that may be auto-bound and gates auto-bind on whether the policy supports bound coverage and claims.
4. Placement: LiabilityPlacementArtifact locks in the selected coverage and premium against a quoted response. Selected amounts must match the quote, and the placement cannot be issued after the quote expires.
5. Bound coverage: LiabilityBoundCoverageArtifact is the carrier-issued policy. Carries policy_number, optional carrier_reference, bound_at, the effective window, the coverage amount, and the premium. Validation requires the underlying provider policy to support both bound coverage and claims.
6. Auto-bind decision (optional): LiabilityAutoBindDecisionArtifact captures whether a placement and bound coverage were issued automatically against the pricing authority, or whether the request was sent to manual review or denied. Reason codes include AuthorityExpired, QuoteExpired, AutoBindDisabled, CoverageExceedsAuthority, PremiumExceedsAuthority, and CapitalUnavailable.

quote_and_bind Helper

The compact path lives in chio-market::insurance_flow and is fail-closed: a missing premium source decline surfaces as InsuranceFlowError::PremiumDeclined rather than a silent approval.

pub fn quote_and_bind(
    agent_id: &str,
    scope: &str,
    lookback_window: LookbackWindow,
    premium_source: &dyn PremiumSource,
    effective_at: u64,
    policy_duration_secs: u64,
) -> Result<BoundPolicy, InsuranceFlowError>

The helper:

1. Pulls PremiumInputs from the caller-supplied PremiumSource.
2. Calls price_premium from chio-underwriting.
3. On a PremiumQuote::Quoted, builds a CoverageLimit equal to 100x the quoted premium and constructs a BoundPolicy.

The 100x default coverage rule is overridable via BoundPolicy::new_with_coverage when a caller has its own coverage sizing.

BoundPolicy

pub struct BoundPolicy {
    pub policy_id: String,            // "insp-<sha256 of canonical body>"
    pub agent_id: String,
    pub scope: String,
    pub premium_quote: PremiumQuote,
    pub coverage_limit: CoverageLimit,
    pub effective_at: u64,
    pub expires_at: u64,
    pub status: PolicyStatus,         // Active | Expired | Cancelled
}

A policy is in-force when status == Active and effective_at <= now < expires_at. A policy that is not in-force at claim time is denied with PolicyNotInForce.

Worked Example

An operator wants ToolExecution coverage for agents in the us-ny jurisdiction, denominated in USD, with a 60-second quote TTL.

let policy = LiabilityJurisdictionPolicy {
    jurisdiction: "us-ny".into(),
    coverage_classes: vec![LiabilityCoverageClass::ToolExecution],
    supported_currencies: vec!["USD".into()],
    required_evidence: vec![
        LiabilityEvidenceRequirement::CreditProviderRiskPackage,
        LiabilityEvidenceRequirement::UnderwritingDecision,
        LiabilityEvidenceRequirement::CreditBond,
    ],
    max_coverage_amount: Some(MonetaryAmount {
        units: 5_000_000,        // $50,000 in cents
        currency: "USD".into(),
    }),
    claims_supported: true,
    quote_ttl_seconds: 60,
    notes: None,
};

The operator assembles the three required evidence artifacts:

• A signed CreditProviderRiskPackage for the agent (exposure ledger, scorecard, facility, recent loss history).
• A signed approved UnderwritingDecisionArtifact.
• A signed active CreditBondArtifact.

The operator submits a LiabilityQuoteRequestArtifact with a $10,000 requested coverage amount and an effective window starting one hour out and ending 30 days later. The provider responds with a quote priced against the risk package; the operator binds via a placement and a bound-coverage artifact, both validated against the original quote response.

Once the bound coverage artifact is issued, claims for ToolExecution incidents within the effective window can be filed. See Claims Lifecycle for the workflow that turns a covered loss into a settlement.

Cross-Jurisdiction Scope

Coverage scope is bounded by the jurisdiction policy that priced it. A bound coverage in us-ny does not extend automatically to us-ca: each jurisdiction has its own policy, evidence requirements, supported currencies, and max-coverage cap. An operator with multi-jurisdiction agents binds one policy per jurisdiction and routes claims to the appropriate provider policy by LiabilityProviderPolicyReference.

For federation across operators (rather than across jurisdictions within a single operator), see Bilateral Federation.

Next Steps

• Claims Lifecycle : how a bound policy turns into an adjudicated payout.
• Underwriting Risk Taxonomy : the inputs that price a premium.
• Credit Facilities & Bonds : the facility and bond evidence that providers consume.