Experience-Driven Autonomy¶

Deploy an autonomous customer support agent with escalation governance, progressive autonomy, and continuous learning from resolved tickets.

Illustrative end-to-end example

A worked illustration of the governance loop — the components and operations are real, but it is not a copy-paste script (some param shapes are condensed). Most steps run offline; autonomous_orchestrator is a sensitive, access-controlled component — a direct invoke_component call returns G6_E_SENSITIVE_COMPONENT_DENIED, so in practice its lifecycle is configured through the authorized orchestration layer, not a public invoke.

GoalInput¶

{
  "goal": "Deploy an autonomous customer support agent with escalation governance",
  "context": "Production support queue handling billing disputes, account recovery, and feature requests. The agent must start human-guided and progressively earn autonomy as confidence scores improve. Escalation thresholds govern when the agent defers to a human operator.",
  "constraints": [
    "Escalation confidence threshold must start at 0.85 and decrease as autonomy increases",
    "All escalated tickets must include a structured rationale",
    "Experience loop must retain at least 100 resolved tickets before autonomy level advances",
    "Human development milestones must be logged and auditable"
  ],
  "resource_bounds": {
    "max_execution_seconds": 600,
    "max_tokens_per_hour": 150000
  },
  "breakpoints": [
    {
      "name": "escalation_review",
      "description": "Pause for human review when autonomy level promotion is proposed",
      "active": true
    }
  ],
  "checkpoints": [
    {
      "name": "confidence_threshold",
      "predicate": "metric_above",
      "params": {"metric": "avg_confidence", "threshold": 0.85},
      "description": "Log warning if average confidence drops below 0.85"
    }
  ],
  "subtasks": [
    {
      "goal": "Set up the agent lifecycle and session management",
      "context": "Use autonomous_orchestrator to initialise the support agent, configure session boundaries, and define the ticket ingestion loop. Each session handles one ticket from intake to resolution or escalation.",
      "constraints": ["Session timeout: 300 seconds", "Max concurrent sessions: 10"]
    },
    {
      "goal": "Configure confidence thresholds for escalation governance",
      "context": "Use autonomy_governor to define when the agent may resolve tickets independently versus escalating to a human operator. Thresholds are per-category: billing_dispute=0.90, account_recovery=0.85, feature_request=0.75.",
      "constraints": [
        "Escalation thresholds must be configurable per ticket category",
        "Governor must enforce a hard ceiling — no autonomous resolution below threshold"
      ]
    },
    {
      "goal": "Process resolved tickets through the experience loop",
      "context": "Use experience_loop to run the attempt-analyse-adapt cycle on each resolved ticket. The attempt phase replays the agent's actions, the analyse phase scores resolution quality, and the adapt phase updates internal heuristics.",
      "constraints": ["Retain full action trace for each ticket", "Adaptation must not regress on previously mastered categories"]
    },
    {
      "goal": "Track progressive handoff from human-guided to fully autonomous",
      "context": "Use human_development to define autonomy milestones. Level 0: human resolves, agent observes. Level 1: agent drafts, human approves. Level 2: agent resolves, human spot-checks. Level 3: fully autonomous with exception escalation.",
      "constraints": ["Each level requires minimum resolved-ticket count", "Regression to a lower level must be possible if error rate spikes"]
    }
  ]
}

Pipeline Diagram¶

graph TD
    A[autonomous_orchestrator<br/>lifecycle + sessions] -->|ticket intake| B[autonomy_governor<br/>escalation thresholds]
    B -->|resolve autonomously| C[experience_loop<br/>attempt → analyse → adapt]
    B -->|escalate| D[Human Operator]
    D -->|resolved ticket| C
    C -->|adaptation scores| E[human_development<br/>milestone tracking]
    E -->|autonomy level update| B
    E --> F((Progressive Autonomy))

What You Need¶

Tier: Builder
Components: experience_loop, autonomous_orchestrator, autonomy_governor, human_development

Step-by-Step¶

Step 1: Initialise the Agent Lifecycle¶

{
  "component": "autonomous_orchestrator",
  "operation": "initialise",
  "params": {
    "agent_id": "support-agent-01",
    "session_config": {
      "timeout_seconds": 300,
      "max_concurrent": 10,
      "ingestion_source": "ticket_queue"
    },
    "categories": ["billing_dispute", "account_recovery", "feature_request"]
  }
}

autonomous_orchestrator is governed and access-controlled — direct public invoke_component calls are denied (G6_E_SENSITIVE_COMPONENT_DENIED); its lifecycle is set up through the authorized orchestration layer. Conceptually, the orchestrator creates a persistent agent identity, binds it to the ticket queue, and begins the intake loop. Each incoming ticket spawns a session with its own timeout and trace log.

Step 2: Set Escalation Thresholds¶

{
  "component": "autonomy_governor",
  "operation": "set_autonomy",
  "params": {
    "agent_id": "support-agent-01",
    "thresholds": {
      "billing_dispute": 0.90,
      "account_recovery": 0.85,
      "feature_request": 0.75
    },
    "escalation_policy": "hard_ceiling",
    "require_rationale": true
  }
}

The governor enforces a hard ceiling: if the agent's confidence for a given ticket falls below the category threshold, it must escalate with a structured rationale. No autonomous resolution is permitted below the threshold.

Why Per-Category Thresholds?

Billing disputes carry financial risk and require higher confidence before autonomous resolution. Feature requests are lower-stakes — the agent can act more independently sooner. Per-category thresholds let the system be conservative where it matters and permissive where it is safe.

Step 3: Run the Experience Loop¶

{
  "component": "experience_loop",
  "operation": "record",
  "params": {
    "agent_id": "support-agent-01",
    "ticket_id": "TKT-20260318-0042",
    "cycle": "attempt_analyse_adapt",
    "retain_trace": true
  }
}

The experience loop runs three phases on each resolved ticket:

Attempt — replays the agent's action trace against the ticket context
Analyse — scores resolution quality (time to resolve, customer satisfaction signal, escalation avoidance)
Adapt — updates internal heuristics for the ticket's category based on the analysis scores

{
  "component": "experience_loop",
  "operation": "replay_experience",
  "params": {
    "agent_id": "support-agent-01",
    "min_tickets": 100,
    "categories": ["billing_dispute", "account_recovery", "feature_request"]
  }
}

Non-Regressive Adaptation

The adapt phase includes a regression guard: heuristic updates are rolled back if they would decrease performance on previously mastered ticket categories. This prevents catastrophic forgetting as the agent learns new patterns.

Step 4: Track Progressive Autonomy¶

{
  "component": "human_development",
  "operation": "assess",
  "params": {
    "agent_id": "support-agent-01",
    "milestones": {
      "level_0": {"description": "Human resolves, agent observes", "min_tickets": 0},
      "level_1": {"description": "Agent drafts, human approves", "min_tickets": 50},
      "level_2": {"description": "Agent resolves, human spot-checks", "min_tickets": 200},
      "level_3": {"description": "Fully autonomous with exception escalation", "min_tickets": 500}
    },
    "regression_trigger": {
      "error_rate_threshold": 0.15,
      "window_size": 50
    }
  }
}

The human_development component evaluates whether the agent has met the criteria to advance to the next autonomy level. It also monitors for regression: if the error rate over the most recent 50 tickets exceeds 15%, the agent is demoted one level and the governor thresholds are tightened.

{
  "component": "human_development",
  "operation": "record_outcome",
  "params": {
    "agent_id": "support-agent-01",
    "from_level": 1,
    "to_level": 2,
    "evidence": {
      "tickets_resolved": 214,
      "error_rate": 0.04,
      "avg_confidence": 0.91
    }
  }
}

Auditable Milestones

Every promotion and demotion event is logged with the evidence that triggered it. This audit trail satisfies governance requirements and enables post-hoc analysis of how the agent earned (or lost) autonomy.

What Happened¶

G6 orchestrated four components in a closed governance loop:

autonomous_orchestrator set up the agent lifecycle, session management, and ticket ingestion
autonomy_governor enforced per-category confidence thresholds, blocking autonomous resolution when the agent was uncertain and requiring structured escalation rationales
experience_loop processed every resolved ticket through the attempt-analyse-adapt cycle, building heuristics that improve over time without regressing on mastered categories
human_development tracked the agent's progression from fully human-guided (Level 0) to fully autonomous (Level 3), with automatic demotion if error rates spike

The governance loop is self-reinforcing: better experience scores raise the autonomy level, which lowers escalation rates, which produces more resolved tickets for the experience loop.

Why G6 Over a Bare LLM¶

A capable LLM can draft support responses and follow instructions. G6 adds a structured governance loop — confidence-gated escalation thresholds, an attempt-analyse-adapt learning cycle, progressive autonomy milestones with automatic regression, and an auditable trail. Prebuilt templates compose these into a closed loop where the agent earns autonomy through demonstrated competence, triggered by one GoalInput JSON.