Goals, Plans, Skills Used

Direction Integrity

Every run must begin with explicit goals and success criteria.

Measure

commit completeness

Threshold

>= 99%

Why

No aim, no intelligence.

Strategy Fidelity

Plans must remain aligned with goals, constraints, and risk budgets.

Measure

plan-to-goal consistency

Threshold

>= 95%

Why

Without strategy, capability becomes motion without direction.

Capability Reuse

Successful work should become reusable capability artifacts.

Measure

verified skill reuse rate

Threshold

positive and increasing

Why

Reusable capability is the compounding asset.

Proof Completeness

Every execution must produce replayable evidence.

Measure

proof completeness rate

Threshold

>= 99%

Why

Without proof, learning is mythology.

Selection Discipline

Only proven upgrades may propagate.

Measure

negative-control rejection rate

Threshold

100%

Why

The network must select reality, not persuasive noise.

Rollback Sovereignty

Every propagated upgrade must be reversible or containable.

Measure

rollback readiness

Threshold

>= 99%

Why

Evolution without rollback is not governable.

Public Evidence

Every flagship proof must have a page, receipt, report, checksum, and root link.

Measure

archive completeness

Threshold

100%

Why

The public system must explain itself from evidence.

Commit Standardization Plan

Turn every job into a structured commitment before execution.

Steps

define goal → define success/failure criteria → bind constraints → bind risk budget → bind evals

Linked goals

Direction Integrity, Proof Completeness

Risk budget

low

Artifact Resolution Plan

Resolve only the active artifacts needed for the run.

Steps

select goals → select plans → select skills → select tools → bind policies → execute

Linked goals

Strategy Fidelity, Capability Reuse

Risk budget

bounded by policy and approval rules

Proof Ledger Plan

Capture every execution as append-only evidence.

Steps

capture trace → capture costs → capture policy decisions → capture scores → assign credit

Linked goals

Proof Completeness

Risk budget

zero unlogged production evolution

Selection Gate Plan

Promote upgrades only after proof, canary, monitoring, rollback, and scope checks.

Steps

propose → evaluate → approve → canary → promote → monitor → rollback

Linked goals

Selection Discipline, Rollback Sovereignty

Risk budget

zero unsafe propagation

Artifact Vault Expansion Plan

Version and index reusable intelligence as immutable artifacts.

Steps

version → scope → sign → index → link proof → enable rollback

Linked goals

Capability Reuse, Public Evidence

Risk budget

no unscoped artifact propagation

Command Center Archive Plan

Publish every proof with a permanent page, evidence JSON, report, badge, and root link.

Steps

render page → copy receipt → copy report → copy badge → update registry → verify links

Linked goals

Public Evidence

Risk budget

no missing public evidence links

Negative-Control Discipline Plan

Inject attractive false upgrades to test whether proof selection rejects them.

Steps

generate proxy game → score candidate → run gate → reject if unsupported

Linked goals

Selection Discipline

Risk budget

zero negative-control acceptance

Commit Compiler

Turns a job request into a structured commitment.

Input

job request, constraints, budget, risk, evals

Output

commit artifact

Verifier

Commit Completeness Court

Plan Graph Resolver

Selects the plans and playbooks required for a run.

Input

commit artifact and available strategies

Output

plan graph

Verifier

Plan Fidelity Court

Skill Resolver

Finds and scopes reusable skills for execution.

Input

plan graph, domain, constraints

Output

skill bundle

Verifier

Capability Fit Court

Artifact Vault Curator

Versions, signs, scopes, and indexes reusable intelligence artifacts.

Input

accepted goals, plans, skills, policies, evals

Output

artifact release

Verifier

Artifact Integrity Court

Run Fabric Executor

Executes agents at scale from resolved artifacts while keeping runtime stateless.

Input

execution bundle

Output

execution result

Verifier

Runtime Integrity Court

Proof Trace Capture

Records what happened during execution.

Input

trace, score, tool history, policy decisions, costs

Output

proof trace

Verifier

Replay Court

Credit Assignment

Determines which artifacts contributed to success or failure.

Input

proof trace, evaluator score, feedback

Output

attribution map

Verifier

Causal Attribution Court

Upgrade Proposal Generator

Converts proof and attribution into candidate upgrades.

Input

proof trace, attribution, failure modes

Output

upgrade proposal

Verifier

Proposal Quality Court

Selection Gate Judge

Promotes only what passed proof, risk, rollback, and scope checks.

Input

upgrade proposal, evals, risk, canary result

Output

promote / reject / revise decision

Verifier

Evolution Gate Court

Canary Release Manager

Tests upgrades in limited scope before broad propagation.

Input

approved upgrade, scope, monitoring plan

Output

canary verdict

Verifier

Canary Court

Rollback Planner

Ensures every propagated upgrade can be reversed or contained.

Input

upgrade diff, affected agents, risk register

Output

rollback plan

Verifier

Rollback Court

Negative-Control Generator

Creates attractive but false upgrades to test selection discipline.

Input

benchmark, proxy metric, known shortcut

Output

negative-control candidate

Verifier

Adversarial Court

Archive Publisher

Publishes proof page, evidence JSON, report, badge, checksum, and root link.

Input

proof receipt and generated outputs

Output

proof archive entry

Verifier

Archive Integrity Court

Command Center Integrator

Keeps the root Command Center complete, current, and viewer-friendly.

Input

proof registry, receipts, docs, badges

Output

Public SkillOS Command Center

Verifier

Root Contract Verifier

Live Root Verifier

Checks that /skillos/ and /skillos/index.html remain the Command Center.

Input

live site responses

Output

live root verdict

Verifier

Pages Deployment Court

Evolution Receipt Renderer

Explains agent evolution to non-technical viewers through goals, plans, skills, and proofs.

Input

source protocol JSON and proof archive

Output

viewer-friendly protocol pages

Verifier

Site Integration Verifier

Aim Artifacts

goals, success criteria, constraints, risk boundaries

Strategy Artifacts

plans, playbooks, route graphs, canary plans

Capability Artifacts

skills, tools, context recipes, reusable procedures

Guardrail Artifacts

permissions, vetoes, risk gates, rollback rules

Judgment Artifacts

rubrics, negative controls, holdouts, verifier criteria

Action Artifacts

execution bundles, tool plans, runtime decisions

Grounding Artifacts

context recipes, retrieval scopes, data boundaries

Evolution Artifacts

upgrade candidates, canary verdicts, propagated releases