Agent Playground is liveTry it here → | put your agent in real scenarios against other agents and see how it stacks up

The Big Picture

Separate what an AI agent is allowed to do (capability) from how and where it runs (capacity) with a compact contract layer so teams can add behaviors or scale resources without silently changing outcomes—provided strict monitoring and calibration are enforced.

The Evidence

Organize runtimes around three responsibility objects: a Skill (the business behavior and declared effects), a Harness (the admission gate, contract compiler, and evidence capture), and a Scaffold (the physical execution and isolation). A resolved, inspectable contract that pins inputs, outputs, authorized effects, versions, and binding constraints makes capability changes observable and prevents registry churn from being mistaken for real capability growth. Six measurable obligations and a cluster-period randomized crossover are proposed to test whether adding capabilities or scaling resources changes agent semantics, and to measure the enforcement cost. The work is a reference architecture and falsification protocol rather than a production implementation or empirical deployment report. Event-Driven Agent Pattern
Not sure where to start?Get personalized recommendations
Learn More

Data Highlights

1SkillMD snapshot contains 138,133 content-deduplicated SKILL.md records (evidence that structured metadata is widespread).
2136,380 records (98.73%) include a frontmatter envelope, yet most fields are not validated by default.
3A lexical detector found explicit path tokens in 32,069 records (~23.2%), a lower-bound sign that many Skills reference code or assets.

What This Means

Platform engineers and runtime teams can use the contract design to enforce admission, auditing, and safe rollout of agent behaviors. Product owners, security and data stewards, and operations/SRE teams should care because the contract makes ownership, evidence, and rollback responsibilities explicit—helping reduce accidental policy bypasses and hidden dependencies when you scale or update agents. Agent Service Mesh Pattern

Key Figures

Figure 1: Shown: business capability enters as a versioned Skill contract, the Harness admits and binds an activated path, the Scaffold supplies the execution and control boundary, and the CIO-governed semantic and telemetry substrate remains stack-external; any derived index or summary in that substrate is discovery metadata rather than source authority. Why it matters: the diagram separates the two interventions whose independence P1 tests and identifies the boundary at which recoupling and enforcement cost must be observed. Class: architecture.
Fig 1: Figure 1: Shown: business capability enters as a versioned Skill contract, the Harness admits and binds an activated path, the Scaffold supplies the execution and control boundary, and the CIO-governed semantic and telemetry substrate remains stack-external; any derived index or summary in that substrate is discovery metadata rather than source authority. Why it matters: the diagram separates the two interventions whose independence P1 tests and identifies the boundary at which recoupling and enforcement cost must be observed. Class: architecture.
Figure 2: Shown: a request and activated bundle pass deterministic admission gates to become a resolved Harness contract with typed data, path, authority, budgets, versions, binding, and trace identity. Why it matters: the contract is the inspectable unit on which complete mediation, replay, and capability-to-capacity binding are tested. Class: architecture.
Fig 2: Figure 2: Shown: a request and activated bundle pass deterministic admission gates to become a resolved Harness contract with typed data, path, authority, budgets, versions, binding, and trace identity. Why it matters: the contract is the inspectable unit on which complete mediation, replay, and capability-to-capacity binding are tested. Class: architecture.
Figure 3: Shown: the control plane holds the registry, policy, admission, and placement logic, while the data plane receives only the resolved contract and executes accepted work; the leaking variant injects every schema and policy into the request path. Why it matters: keeping inactive registry state and mutable control metadata off the request path limits unmeasured coupling between capability growth and runtime load. Class: architecture.
Fig 3: Figure 3: Shown: the control plane holds the registry, policy, admission, and placement logic, while the data plane receives only the resolved contract and executes accepted work; the leaking variant injects every schema and policy into the request path. Why it matters: keeping inactive registry state and mutable control metadata off the request path limits unmeasured coupling between capability growth and runtime load. Class: architecture.
Figure 4: Shown: a main agent derives bounded sub-agents for unmet dependencies, then a separate verifier or semantic join checks their returned evidence before a termination gate closes the path. Why it matters: capability expansion during a run remains a sequence of admitted contracts rather than an invisible increase in ambient authority. Class: protocol.
Fig 4: Figure 4: Shown: a main agent derives bounded sub-agents for unmet dependencies, then a separate verifier or semantic join checks their returned evidence before a termination gate closes the path. Why it matters: capability expansion during a run remains a sequence of admitted contracts rather than an invisible increase in ambient authority. Class: protocol.

Ready to evaluate your AI agents?

Learn how ReputAgent helps teams build trustworthy AI through systematic evaluation.

Learn More

Keep in Mind

This is a reference architecture and experiment protocol, not a working system—no measured enforcement overhead or deployment-scale results are provided. Separability (keeping capability and capacity independent) is explicitly bounded: it may hold only within a tested operating region and can break when new hardware, timing, or data drift are introduced. The approach requires thorough instrumentation and calibration (including injected violations) and creates a control-plane concentration risk that must be mitigated with replication and attestation. Defense in Depth Pattern

Methodology & More

Propose a compact, contract-centered architecture that separates responsibilities so business semantics, runtime governance, and physical execution remain distinguishable. A Skill declares intent, input/output schemas, preconditions, visible effects, and a version; the Harness compiles an admitted run into a resolved contract (inputs, outputs, activated graph, authority/evidence obligations, binding constraints, and pinned versions); and the Scaffold supplies the execution boundary and nonfunctional guarantees. An external, CIO-governed data substrate supplies canonical sources and snapshot identity so fetches return typed evidence bundles rather than raw text. To make the architecture testable, define six measured obligations (each with required coverage, violation ceilings, sensitivity floors, and calibration via injected faults) and randomize at the cluster-period level (an isolated worker pool and time epoch). The designed experiment crosses capability activations and capacity configurations to detect whether enabling a new Skill changes capacity response or whether adding capacity changes semantic outcomes; all interventions must be observable in the resolved contracts. The proposal emphasizes Skill-as-Code lifecycles, deterministic gates around probabilistic planning, and evidence capture for replay and audit, while acknowledging practical trade-offs—instrumentation costs, possible false negatives for opaque executors, and the lack of a full implementation or measured enforcement budget. Canary Deployment
Avoid common pitfallsLearn what failures to watch for
Learn More
Credibility Assessment:

No affiliations or author reputation provided and posted on arXiv with zero citations. Limited signals of credibility; treat as emerging/limited info (2 stars).