9 — Agent Operating Procedure — configuration as code, SOP translation & underwriting governance.
The Layerup AI Agent’s reasoning is not hardcoded in its container image. It is governed by its Agent Operating Procedure (AOP) — the agent-native representation of your underwriting Standard Operating Procedure (SOP). The AOP encodes your specific underwriting rules, risk tolerance thresholds, occupation classifications, financial benchmarks, escalation criteria, and flagging logic as a version-controlled, human-readable configuration artifact. This section is addressed to your Platform Engineering and Underwriting Governance teams.9.1 What the AOP is and what it governs
The AOP is the configuration artifact that answers the question: “Given this application, what should the agent evaluate, how should it evaluate it, and when should it escalate?” It is a JSON / YAML artifact stored in your source control system, subject to your change management workflows. It is not embedded in the container image — the image and the AOP are versioned and tracked independently, giving your governance team separate control over software updates and underwriting policy changes. The AOP governs:Underwriting Rules
Explicit rules from your SOP: occupation class definitions, financial documentation requirements by income type, medical flagging criteria by condition category, and cross-referencing logic between document types.
Risk Thresholds
Quantitative thresholds: minimum income documentation sufficiency scores, occupation risk score boundaries by class, confidence floor for auto-approval vs. review vs. escalation, and OCR confidence floor for extraction acceptance.
Escalation Criteria
The specific conditions under which the agent escalates to a human underwriter: confidence threshold, critical data point failure definitions, edge case patterns outside AOP coverage, and senior underwriter routing logic.
Evidence Requirements
What constitutes sufficient evidence for each case dimension: which documents are required, which are optional, and which gaps in the document set trigger requirements rather than flags.
9.2 From SOP to AOP — the onboarding process
The AOP onboarding process is the structured translation of your written (and unwritten) underwriting standard operating procedure into the agent’s configuration format. This is a collaborative engagement between Layerup’s implementation team and your underwriting leadership. Fig. A9.1 — SOP to AOP onboarding pipeline. The process captures both explicit and tacit underwriting knowledge before the AOP is certified for production.Step 1: SOP Document Provision
Your underwriting leadership provides Layerup’s implementation team with the current workflow SOP documents. These may include reinsurance treaty guidelines, occupation class manuals, financial documentation standards, medical underwriting guidelines, and state-specific regulatory requirements.Step 2: Translation
Layerup’s implementation team reviews the SOP documents over an approximately 2–3 day white-glove onboarding period. The team identifies all explicit underwriting rules, converts them to agent-native schema format, and identifies gaps — places where rules are implicit (i.e., they exist in the experience of your senior underwriters rather than in the written document).Step 3: Gap Resolution
Identified gaps are surfaced in a structured Gap Report shared with your underwriting team. Your frontline underwriters contribute the tacit knowledge required to fill those gaps. This is a critical collaborative phase — the goal is to capture the full scope of underwriting judgment, not just what is written.Step 4: AOP Review
The completed AOP configuration is reviewed by both Layerup’s team and your underwriting leads before testing begins. Your team can view, edit, and annotate every AOP field through the Layerup configuration interface — no software engineering expertise is required to review or modify AOP content.Step 5: Testing and Validation
The AOP is tested against a set of your historical cases with known outcomes. Layerup targets greater than 99% reproducibility of the agent’s recommendation across multiple runs of the same case before certifying the AOP as production-ready. Discrepancies between the agent’s recommendation and the historical outcome are reviewed with your underwriting team and used to refine the AOP before promotion.9.3 AOP as a version-controlled artifact
Once finalised, the AOP is stored as a version-controlled JSON / YAML artifact in your source control system (AWS CodeCommit, GitHub Enterprise, or equivalent). This enforces:- Every change to the agent’s underwriting configuration is tracked, attributed to a specific author, and associated with a pull request and approval record.
- Your compliance and audit teams can view the exact AOP version that was active during any historical underwriting decision — the AOP version is logged against every processed case.
- Rolling back to a previous AOP version is a single-command operation via your CI/CD pipeline — the agent picks up the new AOP version on its next case.
- The AOP itself is fully auditable: every field, threshold, and rule is human-readable and reviewable by your underwriting governance team without requiring software engineering expertise.
9.4 SOP update translation pipeline — white-glove and self-service
When your underwriting leadership updates the SOP (e.g., following a state regulatory change, an internal guideline revision, or a new reinsurance treaty), the AOP is updated via one of two mechanisms depending on the magnitude of the change:| update type | trigger | process | approval required |
|---|---|---|---|
| White-Glove (major) | New occupation classes · Revised financial thresholds · New medical guidelines · Reinsurance treaty changes | Layerup implementation team performs structured translation, followed by a full re-validation testing cycle against historical cases before promotion | Your underwriting governance lead + Layerup |
| Self-Service (minor) | Threshold adjustments · Clarifying rule additions · Minor flagging criteria changes | Your designated AOP administrators make direct edits via the configuration interface. Field-level version history, diff view, and AI-assisted translation utility are available. | Your AOP administrator + defined approval workflow in source control |
Self-service interface capabilities
The self-service AOP update interface provides:- Field-level version history — view the exact change history for any individual AOP rule or threshold, attributed to the author who made each change.
- Diff view — side-by-side comparison between any two AOP versions, with the impacted underwriting rules highlighted.
- AI-assisted translation utility — upload a new SOP section or regulatory document and receive a draft set of proposed AOP changes for human review. The draft is never auto-promoted — it requires explicit approval before taking effect.
- Test harness — run the amended AOP against a set of historical validation cases before promotion, with results compared against the established baseline.