┌──────────────────────────────┐
  │    BP Systems of Record      │
  │  SAP · Treasury · CFIN       │
  │  Market Data · Ariba ·       │
  │  BlackLine                   │
  └──────────────┬───────────────┘
                 │  (Read-Only, CDC / REST / Batch)
                 ▼
  ┌──────────────────────────────┐
  │ bp Sphere Intelligence Plane │
  │ Agent Fabric + Governance    │
  └──────────────┬───────────────┘
                 │
                 ▼
  ┌──────────────────────────────┐
  │ Immutable Evidence Vault     │
  │ SHA-256 Sealed               │
  └──────────────┬───────────────┘
                 ▼
  ┌──────────────────────────────┐
  │    BP Decision Makers        │
  │  CFO · Treasurer · Controller│
  └──────────────────────────────┘

Event source:
  SAP CFIN -> journal_posted

bp Sphere processing:
  1. CDC event enters the integration layer
  2. Event is routed to agent.run.request on NATS
  3. ReconciliationAgent and AnomalyDetectionAgent are triggered
  4. Agents detect GL vs subledger mismatch: $2.1M
  5. Decision is emitted: flag discrepancy and recommend investigation
  6. Evidence seals journal_id, reconciliation snapshot, and variance calculation

  ┌────────────────────────────────────────────────┐
  │ EXPERIENCE FABRIC                              │
  │ CFO Command Centre · 50+ UI Surfaces           │
  │ Decision UX · Evidence Explorer · Ontology UI  │
  ├────────────────────────────────────────────────┤
  │ CONVERSATIONAL GATEWAY                         │
  │ Runtime-configured LLM · Explain · Drill       │
  │ Simulate · Recommend                           │
  ├────────────────────────────────────────────────┤
  │ AGENT FABRIC + MESH                            │
  │ 153 Agents · 25 Categories · Agent Mesh       │
  │ Supervisor · HITL · Tick Engine · Role Router  │
  ├────────────────────────────────────────────────┤
  │ GOVERNANCE CORE                                │
  │ Policy Engine · RBAC/PBAC · Kill Switch        │
  │ Autonomy Gating AL1-AL4                        │
  ├────────────────────────────────────────────────┤
  │ ONTOLOGY & SEMANTIC LAYER                      │
  │ 4-Layer Object Model · Trigger Engine          │
  │ Cross-Domain Bridges · Tenant Packs            │
  ├────────────────────────────────────────────────┤
  │ EVIDENCE & CONTEXT LAYER                       │
  │ Decision Ledger · Canonical Entities           │
  │ SHA-256 Replay · Knowledge Graph (Neo4j)       │
  ├────────────────────────────────────────────────┤
  │ EVENT BACKBONE                                 │
  │ NATS JetStream · Async Subjects                │
  │ Agent Execution Events                         │
  ├────────────────────────────────────────────────┤
  │ FABRIC ORCHESTRATION                           │
  │ 10 Fabrics · Workflow · Guardian · Trust   │
  │ AI Mesh · Saga · Federated Gateway             │
  ├────────────────────────────────────────────────┤
  │ INTEGRATION LAYER                              │
  │ 114 SOR Adapters · CDC · REST · Batch          │
  └────────────────────────────────────────────────┘

Agent:
  name: ReconciliationAgent
  domain: R2R

Trigger:
  kpi.threshold.crossed (GL mismatch)

Execution:
  - Fetch GL balance from canonical snapshot
  - Fetch subledger totals from canonical snapshot
  - Compute variance deterministically

Decision output:
  - mismatch_detected: true
  - variance_amount: $2.1M
  - severity: HIGH

Policy check:
  - materiality > $1M -> escalate

Result:
  - policy.violation event emitted
  - decision record created

• Architecture now explicitly separates runtime mode from deployment environment.
• Demo/showcase, dev, and prod are distinct deployments; public workers can be pointed independently to demo, dev, or prod surfaces.
• Mission pages now pre-render initial tab state server-side, fixing cache/path drift on FP&A deep links.

User (UI / API / Guided Mode)
        |
        v
CCL Router (role + intent + mode)
        |
        |-- Explain / Drill / Simulate / Recommend
        |
        |-- Click Orchestration Plan (deterministic)
        |
        |-- Evidence Binding Plan (required)
        |
        +-- Policy Safety Gate (required)
        |
        v
Domain Copilots + Scenario Engine
        |
        v
Response + Step Plan + Proof Bar
(mode . confidence . sources . policy_version . replay_id . evidence_hash)

User Query (UI / API)
        |
        v
+-----------------------------------------------------------+
| Enterprise Chat Command Layer (api/enterprise_chat.py)    |
|  UI   /ui/enterprise-chat                                 |
|  POST /api/iaf/enterprise-chat/ask                        |
|  Routes: Journal . Recon . Invoice . Cash . Treasury . FP&A|
|  Emits: capability . confidence . policy . evidence . path |
+-------------------------+---------------------------------+
                          |
                          v
+-----------------------------------------------------------+
| FP&A Copilot (api/fpa_copilot.py)                         |
|  POST /api/iaf/fpa-copilot/ask        (JSON)              |
|  POST /api/iaf/fpa-copilot/ask-stream (SSE)               |
|  Model: gpt-5.4-mini . runtime-configured               |
|  Modes: Explain . Drill . Simulate . Recommend            |
+-----------------------------------------------------------+
| CFO Intelligence (api/cfo_intelligence.py)                |
|  POST /api/iaf/cfo/chat                                   |
|  POST /api/iaf/cfo/scenario/interpret                     |
|  POST /api/iaf/cfo/exposure/compute                       |
+-----------------------------------------------------------+
| CFO Scenario Engine (api/cfo_scenario.py)                 |
|  GET /baseline  POST /simulate  POST /monte-carlo         |
|  GET /guardrails  GET /capital-allocation                  |
|  POST /evidence-pack  GET /recommendations                |
+-------------------------+-------------------------------+
                          |
                          v
Evidence Pack (SHA-256) + Governance Metadata + Replay Pointer

CCL sits above these runtime services and produces: a user response, a guided click plan, and a proof bar (always-on credibility controls).

• Conversational Finance AI uses a single runtime model setting via OPENAI_MODEL.
• Preset simulations use deterministic finance math for numbers and LLM-generated executive narrative for explanation.
• Current production-safe default has been tuned back to gpt-5.4-mini for reliability and latency over gpt-5-mini.

The ontology is organized in 4 layers. Lower layers provide universal abstractions; upper layers bind to agents and produce auditable evidence.

  ┌────────────────────────────────────────────────┐
  │ EVIDENCE LAYER                                 │
  │ EvidencePack · Decision · AuditTrail           │
  ├────────────────────────────────────────────────┤
  │ DECISION LAYER                                 │
  │ AgentExecution · PolicyEvaluation              │
  │ Recommendation · Confidence · ReasoningChain   │
  ├────────────────────────────────────────────────┤
  │ DOMAIN LAYERS (extensible per domain)          │
  │ Finance: Invoice · Supplier · PurchaseOrder    │
  │          Payment · BankAccount · GLPosting     │
  │ HSE:     Permit · Incident · RiskRegister     │
  │ HR:      Employee · TimeEntry · Payroll       │
  ├────────────────────────────────────────────────┤
  │ CORE / KERNEL LAYER                            │
  │ Party · OrganizationUnit · Agreement           │
  │ Account · EvidencePack                         │
  └────────────────────────────────────────────────┘

Core / Kernel Objects

Finance Domain Objects

• The ontology is now visible in live agent surfaces through entity_type and ontology_refs on recommendations and traces.
• Lease, payment, obligation, and finance objects are tied into drawer-level drilldowns rather than narrative-only cards.
• Cross-object drill paths now include transaction → trace → evidence navigation.

• Knowledge graph patterns remain part of the architecture narrative, but current finance credibility is driven primarily by reconciled models, policy metadata, and evidence linkage.
• Where graph reasoning is not the primary live path, the pack now needs to treat it as architecture capability rather than overclaiming default execution for every flow.

  Signal / Schedule / SOR Event
              │
              ▼
  Mission Router (API Layer)
              │
              ▼
  Governance Pre-Check
              │
              ▼
  Agent Runtime Queue (NATS Subject)
              │
              ▼
  Agent Worker Pod (Horizontally Scalable)
              │
              ▼
  Decision Envelope Sealing
              │
              ▼
  Evidence Vault + Decision Ledger

Step 1 — Trigger

Every trigger receives: correlation_id · tenant_id · mission_id · trace_id

Step 2 — Mission Router

• Validates mission scope
• Resolves domain
• Loads agent registry entry
• Verifies active deployment version

No dynamic agent injection allowed.

Step 3 — Policy Pre-Check

If denied → BLOCKED. If escalation required → AUTHORITY QUEUE. No execution occurs before this gate.

Step 4 — Agent Execution Envelope

• Context snapshot frozen
• Inputs canonicalised — hash pre-computed
• LLM call (if required) wrapped in policy-bound interface
• Output normalised to schema
• Determinism check applied

Step 5 — Decision Resolution

Each outcome sealed with: inputs_hash · outputs_hash · evidence_hash · policy_id · autonomy_level · sor_provenance[]

• Runtime behavior has been migrated off scattered env branches onto profile-backed settings.
• Startup/runtime verification now exposes a snapshot contract through /api/runtime-profile plus startup logging.
• Core agentic surfaces now show decision/action/evidence sections rather than only KPI tiles and chat.

  Task Request → Role Router
      ├── CAPABILITY_MATCH (best fit)
      ├── ROLE_BASED (role priority)
      ├── ROUND_ROBIN (fair distribution)
      ├── LEAST_LOADED (load balancing)
      ├── PRIORITY (highest priority)
      └── COST_OPTIMIZED (lowest cost)
              │
      RoutingDecision → Mesh Execution
      → output + tokens + execution_order

14 Agent Capabilities

8 Task Types

• Scenario presets are first-class named inputs instead of freeform demo prompts.
• Trigger realism has been expanded with mission-specific scenario/question catalogs and live recommendation/trace/evidence flows.
• In bp Sphere domain apps, multi-stack drawers now surface real transaction objects instead of static trace placeholders.

  Agent Decision Candidate
              │
              ▼
  Policy + Materiality Engine
              │
              ├── AL-permitted ──────────▶ Execute + Seal Evidence
              │
              └── Approval Required
                      │
                      ▼
            Authority Queue (Event-backed)
                      │
              Role-Routed Assignment
                      │
                      ▼
            Approve / Modify / Reject / Timeout
                      │
                      ▼
        Decision Ledger + Evidence Sealing

• Demo and prod authority behavior are now distinguished primarily by runtime profile and role forcing, not by separate code paths.
• Showcase remains the right public demo shell; prod should keep the broader shell and not inherit demo role forcing.

    Agent Execution Request
            │
            ▼
    1. Registry Validation
            │
            ▼
    2. Autonomy Gate Assessment
            │
            ▼
    3. Policy Evaluation Engine
            │
            ├── Permitted ──────────────▶ Execute
            │
            └── Approval Required ──────▶ Authority Queue
                                             │
                                             ▼
                                    Resume / Reject
                                             │
                                             ▼
    4. Monitoring + Drift Check
            │
            ▼
    5. Evidence Seal + Ledger Write

There is no direct execution path around this flow.

• Supervisory behavior now has stronger runtime observability through profile snapshots and environment separation.
• Public worker routing has been cleaned so demo, dev, and prod can be exposed separately instead of reusing one public URL for everything.

    Agent Decision Envelope
            │
            ▼
    Load Active Policy Set (tenant + global)
            │
            ▼
    Evaluate Rule Graph
            │
            ▼
    Resolution Engine
            │
            ├── APPROVE ──────▶ Seal + Continue
            ├── ESCALATE ─────▶ Authority Queue
            ├── BLOCK ────────▶ Close + Evidence
            └── MODIFY REQ ───▶ Re-evaluate

There is no bypass path around this engine.

The engine consists of six deterministic stages:

Each evaluation logs:

Replay always uses original policy_version.

• Policy control is now backed by runtime profiles, policy metadata in traces, and environment-specific behavior settings.
• The pack should now describe the authoritative mode switch as IRIS_RUNTIME_MODE, not scattered IRIS_SKIP_* flags.

Every execution produces a sealed envelope with the following fields:

Canonical entities provide a normalized, cross-domain schema that:

SOR remains system of record.

Canonical entity: Invoice INV-88921

Source references:
  - SAP: 480002194
  - Ariba: IR-22091
  - BlackLine case: BL-9921

Normalized fields:
  - supplier_id: SUP-334
  - amount_usd: 12400000
  - variance_pct: 3.8
  - policy_refs:
      - p2p_policy.yaml#variance_rule

Decision use:
  - shared by P2P, close, and treasury reasoning without mutating ERP truth

Canonical entities are resolved and stored in normalized form while preserving source_refs.

    BP Systems of Record (114 SORs across 5 Domains)
    ┌─────────────────────────────────────────────────┐
    │ Finance (44)    │ Operations (32) │ Energy (19) │
    │ SAP · CFIN      │ ServiceNow      │ Trading     │
    │ BlackLine       │ Ariba · GRC     │ Market Data │
    │ Treasury        │ Workday · HR    │ Upstream    │
    ├─────────────────┼─────────────────┼─────────────┤
    │ Analytics (13)  │ Platform (12)               │
    │ Planning Hub    │ bp Sphere · Fabrics         │
    │ Forecasting     │ Governance                  │
    └─────────────────────────────────────────────────┘
            │
            ▼
    Integration Plane (10 Fabrics · Kubernetes)
            │
            ├── API Adapters (REST / OData)
            ├── CDC Listeners (Event Streams)
            ├── Batch Loaders (Scheduled)
            ├── Federated Gateway (GraphQL)
            ├── Saga Fabric (Distributed Tx)
            ├── Provenance Tracker
            │
            ▼
    Canonical Context Snapshots
            │
            ▼
    Agent Runtime (Read-Only)

Integration is physically and logically isolated from the agent fabric.

Zero operational disruption to SAP or Treasury platforms.

• Public worker topology is now intentionally split: demo/showcase, dev, and prod can each be mapped to separate workers.
• Tech pack integration language should distinguish stable service topology from temporary quick-tunnel worker exposure used for public previews.

Metrics tracked per-agent and aggregated per-tower. Failure to meet SLO triggers investigation workflow.

    Request → Correlation ID
            → Execution Telemetry
            → Policy Evaluation Log
            → Evidence Pack
            → Prometheus Metrics
            → Alerting Rule Evaluation
            → Incident Workflow

Every execution is observable at:

No black-box execution path exists.

• Observability now includes runtime profile snapshots and environment verification endpoints, not only generic telemetry claims.
• Recent platform validation work also refreshed live cluster-state reporting to avoid stale audit summaries.

Compromise of one component does not cascade.

    External User
            │
            ▼
    Azure API Management (Rate limiting, IP filter)
            │
            ▼
    AuthMiddleware (JWT Validation)
            │
            ▼
    RBAC + Domain Engine
            │
            ▼
    Supervisory Control Plane
            │
            ▼
    Agent Runtime

Internal services communicate via:

There is no direct bypass path.

• Security/configuration cleanup has reduced model selection sprawl: LLM choice is now driven from one config setting rather than multiple defaults.
• Environment-specific behavior should now be described as profile-driven and policy-governed, not as ad hoc deployment flags.

USER EXPERIENCE
  CFO . FP&A . Tower Leaders . 50+ UI Surfaces
------------------------------------------------------
CONVERSATIONAL GATEWAY
  Runtime-configured LLM . Controlled Interface
------------------------------------------------------
bp Sphere API GATEWAY
  FastAPI . 300+ routes . 6-layer fail-closed middleware
------------------------------------------------------
AGENT FABRIC
  153 Agents . Supervisor . HITL . Tick Engine
------------------------------------------------------
EVENT BACKBONE
  NATS JetStream . CDC bridge . Async triggers
------------------------------------------------------
GOVERNANCE CORE
  Policy Engine . RBAC/PBAC . Autonomy controls
------------------------------------------------------
DATA PLANE
  PostgreSQL Primary + Replica . Evidence Vault
------------------------------------------------------
INTEGRATION LAYER
  114 SOR Adapters . CDC . REST . Batch
------------------------------------------------------
KUBERNETES ORCHESTRATION
  Deployments . StatefulSets . HPA . Ingress
------------------------------------------------------
INFRASTRUCTURE
  VPC . Subnets . TLS . Persistent Storage

This is a control plane, not an application server.

Core Resources

Health Probes

Pod Security Hardening

Zero privileged containers.