Standard Conformance Quickstart

Standard-profile alpha governance for interactive applications and user-facing systems.

• Claimable now: Standard
• Optional additive badge: Regulated Controls Badge
• Non-conformant runtime mode: Dev Mode
• Future profile track: Safety-Critical (not claimable in alpha)

Python is the canonical alpha runtime evaluator. If your application runtime is not Python, emit traces and evidence locally and call a supported evaluator service for governance execution.

The trace-to-decision walkthrough uses the same canonical source-blueprint and trace vocabulary shown here, then layers the service-bound deployment artifact chain around that evaluation.

Production Profile

Designed for: Production apps and interactive systems

Performance: Typical 50ms-300ms governance path at Governance Tier GT-2/GT-3
Features: Full intervention model, tripwires, trust debt, persistent auditability

---

What You Get

Standard conformance adds production-critical controls while keeping latency predictable.

SDK naming

The SDK parameter conformance_level="standard" maps to Standard Profile.

Feature	Dev Mode	Standard
Core policy (checks, tripwires, intervention_policy)	[YES]	[YES]
All intervention handling	[LIMITED]	[YES]
Trust debt controls	[NO]	[YES]
Persistent auditability	[NO]	[YES]
Optional Runtime Governance Contracts extension	[NO]	[OPTIONAL]

Time to implement: 1-2 days

---

Minimal Useful Standard Implementation

The smallest useful Standard deployment is:

• one Governance Steward
• one Operating Agent runtime
• one active baseline blueprint
• deterministic checks and tripwire evaluation
• CTQ aggregation using the five standard metrics
• threshold mapping and orthogonal flag support
• default trust debt provider behavior
• Governance Store or equivalent durable governance persistence

For the normative baseline and scorer-processing note, see ACGP-3.

For non-Python deployments, keep this same minimal baseline behind an evaluator service rather than trying to run local TypeScript runtime evaluation.

---

Step 1: Install

pip install "acgp-sdk[postgres]"

---

Step 2: Create a Normative Standard Blueprint

Use the canonical Blueprint source shape (artifact_type, schema_version, checks, intervention_policy.thresholds, tripwires, trust_policy).

blueprint.yaml

artifact_type: acgp.blueprint
schema_version: "2.0.0"
id: customer-support/standard@2.0
version: "2.0.0"
title: "Customer support standard blueprint"
description: "Standard governance policy for customer support automation"

applicability:
  governance_tiers: ["GT-2", "GT-3"]

checks:
  - id: refund_reason_quality
    kind: metric
    when:
      hook: tool_call
      tool: issue_refund
    metric:
      name: reason_quality
      weight: 0.55
      evaluator:
        kind: rule-based
        args:
          mode: all
          rules:
            - id: refund_reason_present
              field: parameters.reason
              operator: exists
            - id: refund_reason_descriptive
              field: parameters.reason
              operator: regex
              value: ".{25,}"

  - id: amount_consistency
    kind: metric
    when:
      hook: tool_call
      tool: issue_refund
    metric:
      name: amount_consistency
      weight: 0.45
      evaluator:
        kind: source-match
        args:
          require_order_match: true

intervention_policy:
  thresholds:
    ok: 0.25
    nudge: 0.40
    escalate: 0.55

tripwires:
  - id: daily_refund_limit
    when:
      hook: tool_call
      tool: issue_refund
    condition: "daily_refunds > 5000"
    eval_tier: 0
    on_fail:
      decision: halt
      reason: "Daily refund limit exceeded"

  - id: high_value_refund
    when:
      hook: tool_call
      tool: issue_refund
    condition: "args.amount > 100000"
    eval_tier: 1
    on_fail:
      decision: escalate
      reason: "High-value refund requires approval"

trust_policy:
  enabled: true
  accumulation:
    ok: 0.0
    flag: 0.10
    nudge: 0.50
    escalate: 1.00
    block: 2.00
    halt: 5.00
  decay:
    decay_fraction: 0.05
    period_hours: 24
    min_debt: 0.0
  thresholds:
    elevated_monitoring: 0.30
    restricted_mode: 0.50
    re_tiering_review: 0.75

---

Step 3: Evaluate Traces and Handle Outcomes

from acgp import GovernanceSteward, CognitiveTrace, PostgresStateStorage

steward = GovernanceSteward.production(
    blueprint_file="blueprint.yaml",
    state_storage=PostgresStateStorage(connection_string="postgresql://runtime/acgp"),
)

trace = CognitiveTrace(
    reasoning=(
        "Customer requested refund for defective product. "
        "Order #12345 was delivered 5 days ago and qualifies under policy."
    ),
    action="issue_refund",
    parameters={"order_id": "12345", "amount": 250.0, "reason": "defective_product"},
    confidence=0.92,
    governance_tier="GT-3",
)

result = steward.evaluate(trace)

if result.intervention == "ok":
    issue_refund(250.0, "12345")
elif result.intervention == "nudge":
    log.info("Nudge: %s", result.message)
    issue_refund(250.0, "12345")
elif result.intervention == "escalate":
    approval = request_human_approval(trace, result)
    if approval.approved:
        issue_refund(250.0, "12345")
elif result.intervention == "block":
    notify_customer(f"Cannot process refund: {result.message}")
elif result.intervention == "halt":
    notify_ops_team("Agent halted due to critical violation")
    raise RuntimeError(result.message)

# Orthogonal flag handling (flag is not a primary decision value on the wire)
if result.flags and result.flags.flagged:
    audit.flag_for_review(trace, result.flags.reason)

Use GovernanceSteward(...) for development, test, or advanced bootstrap flows. Standard production examples should start from GovernanceSteward.production(...) so durable runtime state is explicit.

---

Step 4: Optional Runtime Governance Contracts Extension

Runtime Governance Contracts are optional in Standard and currently an extension surface.

They add per-evaluation timeout policy for negotiated latency budgets. Core v1.0 profile-failure fallback for Steward/session-path unavailability remains separate.

optional-governance-contract.yaml

governance_contract:
  risk_level: elevated_risk
  eval_tier: 1
  performance_budget:
    latency_budget_ms: 300
    fallback_on_timeout: cached_decision
    tier_budgets:
      tier_0: 50
      tier_1: 250

Use contracts when you need action-specific latency/risk tuning; otherwise Standard policy works without them.

v1.0 conformance boundary

Eval Tier 2 remains reserved for v1.0 conformance validation. If implemented, treat Tier 2 usage as non-normative extension behavior.

---

Standard Deployment Checklist

• Use canonical blueprint fields for the current Blueprint contract
• Handle Standard intervention outcomes with explicit escalation, block, and halt paths
• Integrate persistent storage and monitoring
• Add Runtime Governance Contracts only if you need per-action latency negotiation

One Concrete Artifact Chain

If you want one complete request-to-audit example before wiring your own system, use the Trace to Decision Walkthrough.

It includes:

• one blueprint artifact
• one trace request artifact
• one decision artifact
• one orthogonal flag artifact
• one trust-debt update artifact
• one audit record artifact

---

Next Steps

• Performance Tuning

  ---

  Optimize evaluation latency and throughput under production load

  Performance Guide

• Trace to Decision Walkthrough

---

One stitched request-to-audit example using the supported evaluator-service path

Walkthrough

• Security Hardening

  ---

  Deployment-level hardening checklist and operational safeguards

  Security Guide