Teach the system without letting it quietly teach itself.

1. 01

   Freeze state

   Create an immutable Decision Context from accepted claims, the resolved pack set, objectives, policies, alternatives, uncertainty, and authority requirements.

2. 02

   Bind policy

   Create the Decision Context after baseline deployment. It freezes the active policy descriptor, and the episode must honor that version even after a later deployment.

3. 03

   Record reasoning

   Store input and output hashes, model and prompt versions, tool versions, latency, cost, trace, and action probability when off-policy evaluation will need it.

4. 04

   Authorize and execute

   Keep recommendation, authorization, and execution separate. External effects require an idempotent attempt and a successful execution receipt.

5. 05

   Observe

   Record sourced measurements after execution. An observation is not automatically an accepted business fact and is not automatically caused by the action.

6. 06

   Assess reward

   Evaluate the observation vector against direction, weight, baseline, window, attribution method, and guardrails. Do not hide a failed guardrail inside one scalar.

7. 07

   Close episode

   Close only after the authorized decision is bound, required measurements are complete, no execution attempts remain unresolved, and every guardrail violation has an independent waiver.

8. 08

   Challenge and promote

   Build from training episodes, evaluate against a disjoint holdout, require action coverage, inspect intervals and safety, then let a different human promote the immutable version.

import { T2kClient } from "@t2kai/core";

// The agent API is a structured decision problem, not a prompt.
const episode = await t2k.createDecisionEpisode(graphKey, {
  episodeKey: "episode:owner-dependency:2026-07",
  // This context was created after baseline deployment and froze that binding.
  decisionContextKey: "decision:owner-dependency:2026-07"
});

await t2k.recordReasoningRun(episode.id, {
  runKey: "run:owner-dependency:001",
  modelRef: "agent:operations-reviewer",
  promptVersion: "owner-dependency-v3",
  codeVersion: gitSha,
  inputHash: context.contextHash,
  outputHash: recommendationHash
});

await t2k.recordEpisodeObservation(episode.id, {
  measureRef: "operations.owner_approval_share",
  observedValue: 0.42,
  baselineValue: 0.71,
  observationWindow: "90d",
  sourceRefs: ["workflow://approvals/2026-q3"],
  provenance: { method: "approval_log_aggregation" },
  observedAt: new Date().toISOString()
});

const assessment = await t2k.assessEpisodeReward(episode.id, {
  assessmentKey: "assessment:owner-dependency:90d"
});

if (assessment.lifecycleStatus === "guardrail_violation") {
  throw new Error("Independent waiver or remediation required before closure");
}

await t2k.closeDecisionEpisode(episode.id, "Required review is complete");

const evaluation = await evaluator.evaluateLearningCandidate(candidate.id, {
  evaluationKey: "replay:owner-dependency:1.1.0",
  evaluationType: "historical_replay",
  holdoutEpisodeIds
});

if (evaluation.lifecycleStatus !== "passed") {
  throw new Error("Do not promote an unsupported challenger");
}

await promoter.promoteLearningCandidate(candidate.id, {
  reviewRationale: "Held-out replay passed; intervals and safety reviewed.",
  deploy: true
});