insurance.board.risk.consensus.v1
Overview
Verify that the Forge runtime executes the canonical Insurance Risk Board Consensus Primitive Profile using the production Ensemble execution kernel.
After completing this example you should be able to:
- execute the canonical Ensemble profile
- inspect the consensus process
- verify runtime evidence
- inspect generated artifacts
- validate deterministic replay
This document verifies Ensemble execution.
It does not validate underwriting strategy, solvency policy, or insurance governance decisions.
Primitive Profile
| Property | Value |
|---|---|
| Primitive | ensemble@1 |
| Profile | insurance.board.risk.consensus.v1 |
| Runtime | Compute |
| Replay | Supported |
| Artifacts | Supported |
| Deterministic | Supported |
| CPU | Supported |
| GPU | Not Required |
Capability
insurance.board.risk.consensus.v1 executes a deterministic consensus process across multiple insurance risk evaluation perspectives.
Rather than producing a recommendation from a single analytical path, the Ensemble kernel evaluates multiple independent participants according to the registered Primitive Profile before producing a consolidated decision.
Typical evaluation dimensions may include capital adequacy, underwriting exposure, catastrophe accumulation, counterparty concentration, liquidity resilience, and operational considerations.
The objective is not to automate governance.
The objective is to produce a reproducible, inspectable, and replayable consensus computation.
Canonical Contract
Execution uses the canonical Forge Ensemble execution contract.
Primitive
ensemble
Version
1
Profile
insurance.board.risk.consensus.v1Requests are validated before entering the execution runtime.
The canonical payload contains:
op.name
op.version
op.profile
argsOptional execution metadata may include:
ctx
seed
policyRequired Inputs
The canonical execution contract requires a valid risk review request together with profile-specific execution parameters.
Typical required execution surfaces include:
- review context
- participant configuration
- evaluation objective
- consensus strategy
Execution begins only after successful canonical validation.
Optional Inputs
Depending on execution policy, optional inputs may include:
- participant weighting
- confidence thresholds
- supporting evidence
- disagreement handling policy
- replay configuration
- execution metadata
Only profile-supported fields should be supplied.
Unsupported fields are rejected during validation.
Canonical Smoke
The maintained Ensemble smoke verifies:
- successful profile resolution
- canonical validation
- participant initialization
- deterministic consensus execution
- runtime evidence generation
- replay metadata generation
- artifact availability
The maintained Smoke Suite remains the canonical executable source.
Verification Expectations
A successful execution should demonstrate:
- canonical validation succeeds
- participant execution succeeds
- deterministic consensus completes
- review outcome is generated
- agreement metrics are available
- runtime evidence is produced
- replay metadata is available
- execution artifacts are generated
Verification includes inspection of both the consensus result and the execution process that produced it.
Runtime Evidence
Successful execution exposes runtime evidence including:
- execution identifier
- primitive profile
- execution metadata
- participant count
- consensus summary
- agreement metrics
- disagreement metrics
- confidence values
- replay metadata
- artifact references
The exact evidence surface depends on execution policy.
Replay
Replay should reproduce identical consensus behaviour when executed using the same execution contract, participant configuration, runtime version, and deterministic seed where applicable.
Replay validates the determinism of the Ensemble kernel rather than infrastructure identity.
Replay verification is described in:
→ /verification/replay-determinism
Artifacts
Typical execution artifacts include:
- consensus report
- participant summaries
- agreement analysis
- disagreement analysis
- confidence summary
- execution summary
- replay metadata
Artifacts explain how the final consensus was produced.
Applied Intelligence Modules
This Primitive Profile is reused across multiple Forge Intelligence Modules including:
- Insurance Intelligence
- Reinsurance Intelligence
- Solvency Intelligence
- Capital Intelligence
- Enterprise Risk Intelligence
The execution primitive remains identical while the Primitive Profile defines insurance-specific consensus semantics.
Related Documentation
- /examples/ensemble/
- /verification/
- /verification/capability-verification
- /verification/replay-determinism
- /verification/artifact-inspection
Verification Checklist
| Verification Surface | Status |
|---|---|
| Primitive resolved | ✓ |
| Contract validated | ✓ |
| Participants initialized | ✓ |
| Consensus completed | ✓ |
| Runtime inspected | ✓ |
| Artifacts inspected | ✓ |
| Replay verified | ✓ |
| Negative validation tested | ✓ |
Final Principle
insurance.board.risk.consensus.v1 verifies a versioned Ensemble Primitive Profile rather than an insurance decision.
Its correctness is demonstrated through deterministic consensus execution, observable agreement and disagreement metrics, runtime evidence, replay, and artifact inspection, allowing independent evaluators to reproduce the same consensus process using the canonical execution contract.
Continue in Forge Studio
This document describes the canonical execution contract for this capability.
The Forge documentation explains how this capability works.
Forge Studio allows you to inspect, execute, and verify the live implementation.
Capability Explorer
Browse the live capability catalog, supported execution surfaces, available Primitive Profiles, and execution metadata.
→ https://studio.forgepool.io/capability-explorer
Block Registry
Inspect the registered Primitive Profile, execution contract, block metadata, adapters, versions, and runtime characteristics.
→ https://studio.forgepool.io/studio/blocks-registry
Execute
Execute this capability using Forge Studio, the Execution API, or an MCP-compatible client.
Verify
Before interpreting the result, inspect:
- runtime evidence
- generated artifacts
- deterministic replay
- execution metadata
Trust should be established through independent verification rather than documentation alone.