Contractual Skills: Explicit Task Governance

Updated 5 July 2026

Contractual skills are explicit frameworks that define task goals, inputs, permissions, and verification criteria through readable contracts.
They separate semantic task instructions from enforcement mechanisms, enhancing safety, auditability, and composability in AI systems.
Empirical studies show that contractual skills reduce execution errors and improve checkability and reliability in enterprise and agent architectures.

Searching arXiv for the cited paper and directly related work on contractual skills and contracts-as-skill interfaces. Contractual skills are skills represented, governed, or exercised through explicit contract structures rather than through unstructured instructions alone. In the recent agent literature, the term most directly denotes skills whose SKILL.md body is organized as a readable task contract that makes goals, input boundaries, permissions, human approval points, evidence requirements, output contracts, quality criteria, verification steps, and handoff rules explicit (Liu, 21 May 2026). Related work uses closely allied formulations for role-labeled execution contexts, verifier-backed procedural artifacts, contract-aware embodied capability interfaces, and logic-based contractual representations for service-level agreements, indicating that the core idea is broader than a single implementation: skill execution becomes safer, more auditable, and more composable when assumptions, obligations, acceptance criteria, and failure handling are surfaced explicitly rather than left implicit (Lu et al., 20 Mar 2026).

1. Enterprise AI definition and scope

In the enterprise-agent setting, contractual skills are a GovernSpec-inspired design framework for organizing SKILL.md files as readable task contracts while preserving lightweight skill discovery and progressive loading. The framework is motivated by the claim that, in enterprise settings, a skill often needs to express more than task guidance: goals, input boundaries, permissions, human approval points, evidence requirements, output contracts, quality criteria, verification steps, and handoff rules. On this view, informal prose buries governance rules, whereas contractual skills surface them in predictable sections so that models, maintainers, and evaluators can consistently reference and check the same expectations (Liu, 21 May 2026).

The framework draws a sharp boundary between instructional contracts and enforcement subsystems. SKILL.md is the human-readable instruction artifact that agents load directly; GovernSpec YAML is a structured, validatable source-of-truth contract that can be compiled into multiple artifacts and offline acceptance tests. Model Context Protocol surfaces expose tools, resources, and prompts to the runtime. Tool adapters enforce schemas, permissions, and block unsafe or invalid calls. Runtime guardrails block disallowed actions or content. Tracing and observability connect events to contract fields and acceptance criteria. Evaluation systems map output contracts and verification steps to offline checks. The paper states that contractual skills are best understood as a governance layer that makes task intent, boundaries, and acceptance criteria explicit, not as a standalone safety mechanism (Liu, 21 May 2026).

This distinction matters because it prevents a common conflation of instruction quality with runtime control. A contractual skill can specify that an agent must pause for approval before an external communication or a pricing commitment, but the actual prevention of unsafe calls remains the job of tool adapters, runtime guardrails, approvals, and policy engines. This separation of semantic intent from operational enforcement is a recurring theme across contract-aware agent architectures.

2. Contract structure inside a skill

A contractual skill organizes the body of a skill around named governance fields. The recommended readable task contract contains Purpose or Goals, Inputs or Boundaries, Permissions, Human Approval Points, Evidence Requirements, Output Contract, Quality Criteria, Verification Steps, Handoff Rules, and Versioning. The paper’s worked examples further specify required and optional inputs, missing-data behavior, privacy classes, forbidden tools or commitments, explicit approver roles, facts-versus-assumptions-versus-inferences separation, output sections and length constraints, pre-final self-checks, downstream queue routing, and provenance links to a corresponding govern.yaml artifact (Liu, 21 May 2026).

This structure is designed to coexist with lightweight discovery. Frontmatter remains small, containing elements such as name, description, and triggers, so that agents can discover candidate skills cheaply. Full contractual content is loaded only when the skill is selected. The resulting execution pattern is progressive rather than monolithic: brief listing for retrieval, followed by full contract loading when relevance is established. The paper presents this as a way to preserve context economy without sacrificing governance detail (Liu, 21 May 2026).

A characteristic contract body therefore functions simultaneously as instruction, documentation, and specification. Inputs or Boundaries define what the task is allowed to assume; Permissions define what the agent may read, write, or communicate; Human Approval Points encode explicit pause conditions; Evidence Requirements define what counts as support and how uncertainty must be marked; Output Contract stabilizes schemas and sections; Quality Criteria define acceptance bars; Verification Steps require pre-final checks; and Handoff Rules specify escalation and transfer semantics. In high-risk settings, the paper states that the strongest pattern is dual-track alignment between readable SKILL.md and structured GovernSpec YAML (Liu, 21 May 2026).

3. Contractualization across skill architectures

The enterprise SKILL.md formulation sits within a wider family of contract-based skill representations.

Framework	Contract object	Main function
Contractual skills	Readable task contract in `SKILL.md`	Governance and acceptance criteria
GoSkills	$C(q)=\langle C_{start}, C_{support}, C_{check}, C_{avoid}, B(q), D(q,B)\rangle$	Role-labeled execution context
ContractSkill	$C=(P,S,Q,R,T)$	Verifiable and repairable procedure
ECM Contracts	$C(e)=(\mathit{Sig}_e,\mathit{Beh}_e,\mathit{Res}_e,\mathit{Perm}_e,\mathit{Rec}_e,\mathit{Ver}_e)$	Compatibility and governed composition

In "Group of Skills: Group-Structured Skill Retrieval for Agent Skill Libraries" (Zeng et al., 7 May 2026), the contract object is an execution contract rendered at inference time. Its Start field names the single anchor skill and explains why it should lead execution. Support lists support skills with roles such as prerequisite, parser, formatter, checker, or fallback. Check states visible requirements that must be satisfied before finalizing. Avoid expresses negative-applicability warnings and common misreadings. $B(q)$ is the bounded set of hydrated atomic skill payloads actually exposed to the agent, and $D(q,B)$ is the remaining uncovered high-confidence visible requirements that could not be covered under the budget and constraints. This is contractualization at retrieval time: the skill interface delivered to the model is no longer a flat list but a compact, role-labeled execution context (Zeng et al., 7 May 2026).

In "ContractSkill: Repairable Contract-Based Skills for Multimodal Web Agents" (Lu et al., 20 Mar 2026), a draft skill is compiled into a contracted executable artifact with preconditions, step specifications, postconditions, recovery rules, and termination checks. The state is the browser page state, each step $u_j=(sel_j, act_j, arg_j, \Pi_j)$ carries selectors, actions, arguments, and post-assertions, and the verifier returns structured failures such as NOT_FOUND, WRONG_STATE, ASSERT_FAIL, LOOP_TIMEOUT, and INPUT_INVALID. Repair is defined through a minimal patch objective,

$\Delta^* = \arg\min_\Delta \mathrm{cost}(\Delta)\ \text{subject to}\ \mathrm{Verify}(C+\Delta)=\mathrm{true},$

which turns skill refinement into localized editing rather than full regeneration. Here, a skill contract is procedural and executable rather than merely organizational (Lu et al., 20 Mar 2026).

In "ECM Contracts: Contract-Aware, Versioned, and Governable Capability Interfaces for Embodied Agents" (Qin et al., 10 Apr 2026), contracts govern embodied capability modules rather than textual skills. The six dimensions are functional signature, behavioral assumptions, resource requirements, permission boundaries, recovery semantics, and version compatibility. Composition and upgrade are then checked through explicit predicates such as InstallCompat, ComposeCompat, ChainCompat, and UpgradeCompat. This extends contractualization from task specification to lifecycle-safe composition, release discipline, rollback readiness, and runtime governance (Qin et al., 10 Apr 2026).

An earlier antecedent appears in "Knowledge Representation Concepts for Automated SLA Management" [0611122], which argues that the complexity of contractual logic in service-level agreements requires logical formalisms capable of automated rule chaining, flexibility, inference, and execution. The selected ContractLog formalisms include logic programming derivation rules, deontic logic for obligations, permissions, and prohibitions, defeasible reasoning and exception handling, event-condition-action rules, temporal logic or Event Calculus, and integrity constraints. In that line of work, contractual structure is neither prompt engineering nor packaging; it is a machine-interpretable representation of obligations, exceptions, temporal conditions, and enforcement behavior [0611122].

4. Verification, enforcement, and operational governance

The enterprise framework specifies an execution flow in which the agent discovers a skill through frontmatter, progressively loads the full contract, forms a plan that respects Inputs or Boundaries, Permissions, Human Gates, and Workflow, validates inputs, checks permissions and approval conditions, acts through tools, produces output under the Output Contract, executes Verification Steps, performs Handoff, and emits traces linking inputs, approvals, evidence, verification outcomes, and downstream routing. The paper further recommends that trace records include missing inputs, tool-call parameters and results, policy decisions, verification outcomes, output hashes, section presence, word count, target queue, and acceptance-test results keyed to contract fields (Liu, 21 May 2026).

What is notable is that verification is treated as a first-class contract component rather than as an external afterthought. In the enterprise case, verification can include required-section checks, forbidden-phrase checks, clause-reference checks, and uncertainty-section checks when required inputs are missing. In ContractSkill, the verifier is deterministic and step-localized; execution is checked after each action against URL, DOM, accessibility summaries, visible text, and form values, allowing the first failing check to determine the failure site and the candidate repair operators (Lu et al., 20 Mar 2026). In ECM Contracts, static and pre-deployment checks validate type compatibility, behavioral compatibility, resource compatibility, governance compatibility, and recovery compatibility before installation, composition, or upgrade (Qin et al., 10 Apr 2026).

The same governance logic appears in weaker form in GoSkills. There, verification is partly anticipatory: visible-requirement coverage is preserved by explicitly computing $D(q,B)$ , and coverage-safe backfill adds skills only if they reduce debt, fit the remaining budget, and pass negative applicability constraints. The contract’s Check and Avoid fields externalize what must be satisfied and what failure modes should be avoided, while the explicit Debt field reports what remains uncovered rather than silently repairing it (Zeng et al., 7 May 2026).

This suggests that contractual skills are less a single data structure than a systems pattern. Across textual agents, multimodal web agents, retrieval pipelines, embodied modules, and SLA engines, the contract specifies admissible inputs, acceptable outputs, conditions of action, and structured treatment of failure. The particular representation varies, but the operational purpose remains stable: explicit task semantics support verification, governance, and controlled evolution.

5. Empirical evidence

Empirical results reported across the literature consistently associate contractualization with gains in checkability, failure localization, compatibility screening, or controlled execution.

System	Setting	Headline result
Contractual skills (Liu, 21 May 2026)	Public-skill A/B expansion	Mean quality 4.692 to 4.914; critical-error rate 0.083 to 0.013
ContractSkill (Lu et al., 20 Mar 2026)	VisualWebArena / MiniWoB	9.4% to 28.1% and 10.9% to 37.5% on VWA; 66.5% to 77.5% and 60.5% to 81.0% on MiniWoB
GoSkills (Zeng et al., 7 May 2026)	SkillsBench / ALFWorld	Must-hit $=1.00$ with fewer than 4 skills on average; GPT-5.4 reward 48.9 vs 36.4
ECM Contracts (Qin et al., 10 Apr 2026)	500 chain benchmark	Execution success 98.2%; false-accept 1.8%

For "Contractual Skills: A GovernSpec Design Framework for Enterprise AI Agents" (Liu, 21 May 2026), the first text-generation study covered three enterprise skills, fifteen synthetic tasks, four instruction conditions, and eight generation models, producing 960 outputs and 1680 cross-judge score records. Contractual skills achieved higher mean model-judge scores than no-skill and minimal-skill baselines across all eight models; against plain expanded skills, they were slightly higher on six models and slightly lower on two. In the GPT-5.5 main run, the contractual condition reached a 30/30 required-section pass rate under an automatic checker. The second study compared eight public skills to contractual rewrites across forty-eight synthetic tasks, six generation models, two repeats, and 1152 outputs. In that setting, mean quality increased from 4.692 to 4.914, critical-error rate fell from 0.083 to 0.013, over-execution rate fell from 0.022 to 0.003, and the paired quality delta was $+0.221$ , with 496 pairs favoring the contractual rewrite, 585 ties, and 71 favoring the original. The third study used 192 simulated tool-call records across eight models. Skill conditions usually reduced high-risk attempts; contractual skills yielded zero attempts for six models, while claude-opus-4-7 attempted four and Kimi-K2.6 attempted two high-risk calls. No model falsely claimed completion after a blocked call (Liu, 21 May 2026).

For ContractSkill, the evidence focuses on repairability and cross-model transfer. On VisualWebArena, ContractSkill improved self-generated skills from 9.4% to 28.1% for GLM-4.6V and from 10.9% to 37.5% for Qwen3.5-Plus. On MiniWoB, it improved from 66.5% to 77.5% and from 60.5% to 81.0%, respectively. Repaired artifacts also transferred across models, improving the target model’s self-generated-skill baseline by up to 47.8 points on VisualWebArena and 12.8 points on MiniWoB (Lu et al., 20 Mar 2026).

For GoSkills, the evidence concerns bounded-context retrieval and execution usability. The method preserves visible-requirement coverage under a small skill budget, achieves must-hit $C=(P,S,Q,R,T)$ 0 on 40 annotated SkillsBench items per mode while presenting fewer than four skills on average, and improves reward and agent-only runtime relative to flat and structural baselines. Under GPT-5.4 on SkillsBench, reward is reported as 48.9 versus 36.4 for Graph of Skills, with runtime 352.9s versus 603.7s (Zeng et al., 7 May 2026).

For ECM Contracts, the composition benchmark used 500 random chains from 13 task templates over 10 seeds. Naive admission allowed 500 chains and produced 369 runtime failures; schema-only admitted 299 chains with 173 failures and a false-accept rate of 34.6%; contract-aware admission accepted 100 chains with 9 failures, execution success 98.2%, false-accept 1.8%, and false-reject 8.0%. In upgrade safety, contract-aware classification was correct on 20 of 24 upgrades and achieved 24 of 24 post-upgrade successes, compared with 12 of 24 for semver-only and 8 of 24 for ad hoc baselines (Qin et al., 10 Apr 2026).

6. Broader interpretations in law, requirements, and contract analysis

Outside agent architecture, the phrase can denote professional competence in contract-intensive work. "Contractual Deepfakes: Can LLMs Generate Contracts?" defines contractual skills as the competencies that turn business intent and legal constraints into a workable, enforceable allocation of rights, obligations, risks, and remedies for a specific deal. The listed competencies include contextual understanding of the transaction and parties, legal reasoning and interpretation, issue spotting and risk identification or allocation, deal structuring, tailoring clauses to facts and objectives, ensuring internal consistency, enforceability analysis, regulatory compliance, negotiation strategy and concessions, drafting clarity and ambiguity management, remedies and dispute design, and integration with operations. The paper’s central claim is that LLMs can generate generic and superficially plausible contractual documents but do not perform the contextual and doctrinal work needed for transaction-specific suitability (Mik, 10 Feb 2026).

A related implementation-oriented perspective appears in "Towards Mitigating Perceived Unfairness in Contracts from a Non-Legal Stakeholder's Perspective" (Singhal et al., 2023). There, contractual skill for requirements analysts, engineers, and solution architects consists in spotting ambiguity in material obligations, identifying asymmetry in rights and obligations, detecting unrealistic timelines or SLAs, checking acceptance criteria and traceability, and escalating potentially unfair clauses. The empirical study reported that imbalance in rights or obligations was identified by 11 of 15 non-legal professionals, ambiguity by 9 of 15, project-specific constraints by 6 of 15, and human-level fairness by 4 of 15. On a dataset of proprietary contracts, BERT-based fine-tuning with data augmentation and self-training achieved 84.0% accuracy and outperformed Vicuna-13B chain-of-thought prompting by about 9% accuracy (Singhal et al., 2023).

In requirements engineering, "Requirements Contracts: Definition, Design, and Analysis" (Jureta, 2021) reframes a requirement as a proposition whose status depends on contractual, economic, and engineering relationships rather than on grammar alone. A proposition acquires the role of requirement if and only if there exists a Requirements Contract defining rights and obligations such as the right to request, the obligation to satisfy, the obligation to validate, and remuneration rights and duties; the contract is enacted; and those rights and obligations are exercised or discharged. This recasts requirements work as a contract-backed allocation of decision rights, incentives, validation duties, and economic exchange (Jureta, 2021).

Additional contract-analysis systems make this broader reading concrete. "Contract Statements Knowledge Service for Chatbots" formalizes selected contract statements as hypergraph-based rules exposed through a JSON API, enabling chatbots to answer parameterized contractual questions with deterministic slot filling and missing-parameter prompts (Ruf et al., 2019). "What to Read in a Contract? Party-Specific Summarization of Legal Obligations, Entitlements, and Prohibitions" defines a party-specific extractive summarization task and trains a pairwise importance ranker on about 293K sentence pairs, showing that legal review can be structured around obligations, entitlements, and prohibitions prioritized by party-specific importance rather than by generic summarization heuristics (Sancheti et al., 2022).

Taken together, these works show that the topic has two connected meanings. One concerns the explicit contractualization of machine-usable skills. The other concerns the human skill of drafting, interpreting, operationalizing, and reviewing contracts. The connection is not accidental: both depend on making duties, boundaries, conditions, evidence, and remedies explicit.

7. Limitations, misconceptions, and research directions

A recurring misconception is that contractual skills are equivalent to safety. The enterprise framework explicitly rejects this: contractual skills are not a standalone safety mechanism, and enforcement remains the job of tool adapters, runtime guardrails, approvals, and policy engines (Liu, 21 May 2026). A second misconception is that contractualization is merely a matter of writing longer prompts. The public-skill A/B study shows only modest mean-quality gains over plain expanded skills in some comparisons, which the paper interprets as evidence that the main benefit lies in checkability, governance clarity, and error reduction rather than in raw fluency (Liu, 21 May 2026).

Current limitations differ by subfield. The enterprise framework reports synthetic tasks, model judges rather than expert human raters, an offline simulated tool environment, model and version drift over time, and a provisional field model that organizations may need to adapt (Liu, 21 May 2026). ContractSkill reports authoring overhead, sensitivity to UI changes, verifier dependence on URL, DOM, text, or form-value observability, and a schema tailored to web browsing rather than broader action spaces (Lu et al., 20 Mar 2026). GoSkills depends on visible metadata and deterministic schema extraction, can be brittle under sparse or ambiguous metadata, and cannot guarantee success under small budgets even though it explicitly reports residual debt (Zeng et al., 7 May 2026). ECM Contracts evaluates a modest library of 24 ECMs, uses manual oracle construction, and relies on static checks that do not capture stochastic runtime factors such as sensor noise and timing jitter (Qin et al., 10 Apr 2026).

The broader legal literature adds a further caution. Contract generation by LLMs can yield "documents that resemble contracts" but may be "useless assemblages of inconsistent provisions or contracts that are enforceable but unsuitable for a given transaction." This is not a claim against structured skill contracts in agent systems; rather, it warns that explicit structure does not by itself supply grounded legal reasoning, contextual interpretation, or transaction-specific judgment (Mik, 10 Feb 2026).

Research directions already proposed in the literature include richer contract semantics, stronger evaluation protocols with human calibration and inter-rater reliability, automated conversion of informal skills into contractual form, integration with policy engines, cross-runtime compilation from structured contracts to MCP surfaces and adapter configurations, richer recovery strategies, compositional skill libraries with typed interfaces, and larger-scale ecosystem studies for governed capability registries (Liu, 21 May 2026). This suggests that contractual skills are likely to remain a design axis rather than a single fixed format: a family of methods for turning implicit task knowledge into explicit, verifiable, governable, and evolvable contracts.