Single SourceStudios Engage SSS
v1.0 · MIT / CC‑BY‑4.0 · 72 tests passing

The design contract layer for AI agent skills.

COVENANT.md is a portable, framework-agnostic file format for declaring what a skill is: its domain, public interface, dependencies, typed contracts, and proof-of-correctness fixtures, declared beside SKILL.md and validatable before a single line of implementation is written.

Code: MIT
Spec: CC-BY-4.0
CI passing
72 tests passing
COVENANT.md is the design-contract layer beside SKILL.md inside an agent skill folder. Callers depend on the declared boundary, not on the skill's internals.

Developed as the sibling of LOGIC.md: LOGIC.md describes the flow between steps; COVENANT.md describes the contract of each skill those steps invoke. Complementary, never drawn the same way.

The problem

Skills are folders of prose. There is no enforceable boundary.

A caller, human or agent, has to read the entire folder to learn what a skill exposes, what inputs it requires, what side effects it has, and which outputs it actually produces. When the skill changes, callers find out at runtime. When two skills depend on each other, nothing checks that the contract between them holds. When a model invokes a skill outside its declared surface, nothing catches it.

This isn't a documentation problem. It's a missing-contract problem. COVENANT.md fills that gap. A covenant beside SKILL.md declares what the skill is on five axes and lets a validator and a test runner enforce it.

On the left, a SKILL.md folder with a fuzzy implicit boundary: the caller must read every file to know what is safe to depend on. On the right, the same folder with a COVENANT.md beside SKILL.md, the boundary now declared and typed; the caller depends on the contract, not the internals.
What it is

One file beside SKILL.md. Two required fields.

A markdown file with YAML frontmatter that sits beside SKILL.md in a skill folder. The YAML is the machine-parseable contract; the markdown body is human rationale. Only covenant_version and name are required.

---
covenant_version: "1.0"
name: docx-generation
version: 1.0.0
domain:
  purpose: Create and edit Microsoft Word documents
  scope: Reads and writes .docx files via a structured content object
interface:
  surface:
    - name: render
      accepts: [content, output_path]
      returns: [success]
contracts:
  inputs:
    content: { type: object, required: true }
    output_path: { type: string, required: true }
  outputs:
    success: { type: boolean }
quality:
  fixtures:
    - name: minimal-render
      operation: render
      input: { content: { title: "Hello" }, output_path: "/tmp/out.docx" }
      expect: { success: true }
---

A validator checks this against the spec; a contract-driven runner executes the fixtures against a real or simulated skill runner. If the skill drifts from its own covenant, the gate fails.

The five questions

Every COVENANT.md answers five questions about a skill.

01

Domain

Who are you? The skill's identity and the problem space it owns.

02

Interface

What do you expose? The operations callers may invoke, and nothing more.

03

Dependencies

What do you need? The tools, sibling skills, and environment a correct invocation requires.

04

Contracts

What do you promise? Typed inputs and outputs, plus invariants that hold for every invocation.

05

Quality

How do you prove it? Fixtures and gates that demonstrate the skill meets its contracts.

The five sections of a COVENANT.md, domain, interface, dependencies, contracts, quality, shown as a row of cards, with the Skill (producer) and the Consumer (caller) signing the same agreement at the bottom: a two-party binding.
How it relates

SKILL.md is the how. COVENANT.md is the what.

SKILL.md is the how; COVENANT.md is the what. SKILL.md is procedural knowledge: the steps, scripts, and tools an agent follows. COVENANT.md is the design contract that sits above it, declaring the commitments the skill makes so callers can depend on a boundary rather than on the skill's internals.

LOGIC.md is flow; COVENANT.md is contract. LOGIC.md describes a multi-step reasoning pipeline as a directed graph. COVENANT.md describes a single skill as a bilateral binding. A LOGIC.md step that invokes a skill can assert against that skill's declared contract rather than guessing at its behaviour.

Skills as contracts

State your domain. Expose a narrow interface. Prove it with fixtures.

A skill that publishes a covenant is no longer a folder you have to read in full to trust. It's a party to an agreement. That's the shift: skills as contracts. #SkillsAsContracts

A wax-sealed parchment binding two parties: the Skill (producer) covenants to deliver every declared operation; the Consumer (caller) covenants to call only what is exposed and honour the contracts as written.
When to use it, and when not to

A contract layer, not a quality lever.

✓ Use COVENANT.md when

  • A skill's interface is depended on by other skills, agents, or humans, and the boundary needs to be explicit and enforceable.
  • You maintain a library of skills and want each to declare its operations, typed inputs and outputs, and invariants.
  • You want continuous validation of skills against a spec in CI.
  • You're pairing with LOGIC.md and need each invoked skill to expose a contract the reasoning step can assert against.

You probably don't need it when

  • You have a one-off script with no callers and no interface to declare.
  • The skill is still being prototyped and its surface isn't yet known.
  • You're optimising raw model output quality on a single LLM call. COVENANT.md is a contract layer, not a quality lever.
What it doesn't do COVENANT.md does not make model outputs better. It makes the skill's surface explicit, validatable, and testable, so callers depend on a declared boundary rather than on reading the skill's internals.
Research and background

A deliberate response to two talks that name the problem from opposite sides.

Both transcripts ship in the repo under docs/ so anyone can read the primary source.

Anthropic, Agent Skills: A New Paradigm

Barry and Mahesh's talk introduces Agent Skills as organised folders of composable procedural knowledge. Their roadmap is exactly the gap COVENANT.md closes:

Testing & evaluation... versioning... skill dependencies... sharing & distribution.

quality.fixtures is the testing pipeline. version plus interface.breaking_changes is the versioning lineage. dependencies is the dependency declaration. domain plus a kebab-case name is the marketplace handle.

Source: Agent_Skills_Key_Takeaways.docx

Matt Pocock, Software Fundamentals in the Age of AI

AI thrives in well-structured codebases and breaks in poor ones. Three named primitives are baked directly into COVENANT.md:

Ubiquitous Language (Eric Evans) lives in domain.ubiquitous_language. Deep modules (John Ousterhout) is the domain.depth field. Design the interface; delegate the implementation is the entire separation COVENANT.md formalises beside SKILL.md.

Invest in the design of the system every day., Kent Beck
Source: Software_Fundamentals_in_AI_Age.docx

Anthropic names what skills are missing at the ecosystem layer. Pocock names what skills are missing at the design layer. COVENANT.md is one file that addresses both.

Examples tour

Four worked skills, validated end-to-end.

Each a complete COVENANT.md plus SKILL.md you can validate and run.

markdown-to-html

A single pure transform; the smallest useful covenant.

pdf-generation

Document creation with output contracts.

template-rendering

Typed inputs rendered against a template.

docx-generation

Create, read, and edit operations with invariants, roundtrip fixtures, and quality gates.

Ecosystem, packages, status

Three packages shipped. A Python SDK. A canonical schema.

GovernsFormat
SKILL.mdProcedural knowledgeMarkdown
LOGIC.mdReasoning flow, step DAGsMarkdown / YAML
COVENANT.mdDomain, interface, dependencies, contracts, quality fixturesMarkdown / YAML
3npm packages: core, cli, mcp
6CLI commands
15conformance fixtures
72tests passing

A feel for the CLI

npm install -g @covenant-md/cli

# Validate a covenant against the canonical spec
covenant validate examples/docx-generation/COVENANT.md

# Run its fixtures through a real or simulated skill runner
covenant test examples/docx-generation/

# Interactive scaffold for a new covenant
covenant generate

# Heuristic design checks
covenant lint examples/docx-generation/

# Semantic diff, breaking, additive, cosmetic
covenant diff old/COVENANT.md new/COVENANT.md

# Dependency graph across a skills library
covenant graph examples/

Canonical specification at docs/COVENANT.md. Claude Code plugin ships five slash commands: /covenant:validate, /covenant:check, /covenant:init, /covenant:diff, /covenant:graph. Specification licensed CC-BY-4.0; reference framework (core, cli) licensed MIT.

Get the contract

Declare the skill's boundary once. Let callers depend on it, not on your internals.

Published on npm. MIT licensed code, CC-BY-4.0 spec. Sibling of LOGIC.md and MARCHESE.md.

Evidence stamp

Evidence: compiled from the covenant-md repository on 2026-08-03. Every number on this page traces to a file path or command output in the source tree. Last updated: 2026-08-03.

Single Source

Every number on the dossier and whitepaper pages traces to a file path or command output in the source tree.

LinkedIn Facebook (c) 2026 Single Source Studios (Pty) Ltd