Make the spec the artifact. Then gate CI on it.

Requirements Markup Language is an XML format for software requirements (which your agent will write for you) with a deterministic toolchain: validate the spec, trace it to the code and tests that realize it, and fail the build when they drift apart.

Built for codebases where an agent writes much of the code — and someone still has to know what the system is supposed to do.

Get started View on GitHub

One command scaffolds a spec and an AGENTS.md — works with any coding agent:

npx @rqml/cli init

The whole idea, in one terminal session

fish — ~/myproject

# the agent implements REQ-AUTH-001, then records the link — no hand-edited XML~/myproject ❯ rqml link REQ-AUTH-001 src/auth.ts#verifyToken✓ REQ-AUTH-001 ← src/auth.ts#verifyToken (E-IMPL-AUTH-001, implements, baseline recorded) ~/myproject ❯ rqml check✓ check pass (standard) — requirements.rqml # six weeks later, someone refactors auth without touching the spec…~/myproject ❯ rqml check  error (drift) [changed-implementation]: implements edge "E-IMPL-AUTH-001"    points at "src/auth.ts#verifyToken", which has changed since approval.✗ check fail (standard) — requirements.rqml      (exit 2)

No language model is involved in any of those verdicts. rqml check is a pure function of your repository — same input, same answer, on your laptop and in CI. The model proposes; the toolchain disposes.

Drop it into your coding agent

The Claude Code and Codex plugins make the CLI loop above automatic: every session opens anchored on your spec, every .rqml edit is validated in the same turn, and the turn is gated on rqml check — the same deterministic verdict your CI runs. The plugins ship no engine of their own; they shell out to @rqml/cli, so the agent is held to the same gate as your build.

Early access · v0.1.0

Claude Code plugin

Anchor, validate, and gate Claude in every session. Six /rqml:* commands for the Spec → Design → Plan → Code → Verify loop, plus the bundled MCP tools and an RQML authoring skill.

npm install -g @rqml/cli
# then, inside Claude Code:
/plugin marketplace add rqml-org/rqml-claude
/plugin install rqml@rqml

Get the Claude Code plugin

Early access · v0.1.0

Codex plugin

The same loop for OpenAI Codex: session anchoring, in-turn spec validation, and a stop-time rqml check gate once you trust the plugin's hooks.

npm install -g @rqml/cli
# then, inside Codex:
codex plugin marketplace add rqml-org/rqml-codex
# enable the RQML entry, then trust its hooks

Get the Codex plugin

On a different host? The RQML Agent Skill brings the same workflow to any skill-compatible agent, and the VS Code extension adds in-editor authoring and export. Plugins enforce; these assist.

Not just a format — a deterministic toolchain.

One engine powers a CLI, an MCP server for your agent, and the VS Code extension. Open source (Apache‑2.0), published on npm, fully offline, no telemetry, and no language model in the verdict path.

rqml — the CLI

init, validate, status, and the check gate — plus the agent loop: show, impact, link, skeleton.

npm i -g @rqml/cli

@rqml/core — the engine

Parse, validate (XSD + referential integrity), lint, trace, impact, coverage, drift, and comment-preserving spec edits — embed it in your own tools.

npm i @rqml/core

@rqml/mcp — for agents

Thirteen Model Context Protocol tools backed by the same engine. Reads specs by file path (no pasting 30k tokens into a tool call); writes only on explicit intent.

npx @rqml/mcp

The loop an agent actually runs — read one requirement, check the blast radius, implement, record the link, pass the gate:

rqml show REQ-PAY-001     # one requirement: statement, acceptance criteria, trace neighborhood
rqml impact REQ-PAY-001   # what is affected, transitively, if this changes?
rqml link REQ-PAY-001 src/payments/capture.ts   # implements edge + content-hash baseline
rqml check                # validation + coverage + drift; exit 0 or it isn't done

Explore the tooling Star on GitHub

It eats its own dog food.

The RQML repository is specified in RQML. requirements.rqml defines the language and the toolchain as requirements; every shipped feature was specified before it was built, is linked to the code that implements it and the tests that verify it, and the repo gates its own CI with rqml check.

The name is older than you might guess: RQML began as an XML DTD in a 2000 MSc thesis at the University of York. 2.x is a ground-up redesign of that idea for coding agents.

Read the self-spec →The origin story

What RQML is not

Not a code generator. It never writes your code — your agent does that. RQML is what keeps the agent honest.
Not AI-powered. No model runs anywhere in the toolchain. Verdicts are reproducible functions of your repo.
Not DOORS. A text file in your repo and a small npm package — not an enterprise requirements suite.
Not ceremony. meta plus one requirement is a valid spec. Everything else is optional and added when it earns its keep.

Yes, XML

RQML uses XML because requirements are documents, not just data records.

They mix prose, structure, identifiers, references, comments, validation rules, and future extensions. YAML, TOML, and JSON are excellent for configuration; RQML needs structured text.

XML is not fashionable, but it is boring in useful ways: mixed content, schemas, namespaces, and deterministic validation.

Why XML Why RQML

Eleven sections. Two are mandatory.

A useful spec fits in 15 lines; a serious one scales to thousands of requirements with goals, scenarios, state machines, and a typed traceability graph. Explore the vocabulary:

<meta>
<meta>
  <title>DriveEasy Car Rental Platform - Software Requirements Specification</title>
  <system>DriveEasy</system>
  <summary>
    A web-based system for searching, reserving, picking up, and returning
    rental vehicles across multiple branch locations.
  </summary>
  <authors>
    <author>
      <name>Anna Sigurdsson</name>
      <role>Product Owner</role>
      <org>DriveEasy ehf.</org>
    </author>
  </authors>
  <dates>
    <created>2026-01-15</created>
    <updated>2026-02-20</updated>
    <targetRelease>v1.0.0 - 2026-Q3</targetRelease>
  </dates>
  <profiles>
    <profile id="PROF-GDPR" type="compliance">
      <description>GDPR compliance for personal data processing.</description>
    </profile>
  </profiles>
</meta>

Only <meta> and <requirements> are required — the other nine sections are optional, added when they earn their keep.

Read the docs Get started

Start right now

Scaffold — npx @rqml/cli init drops a requirements.rqml and an AGENTS.md in your project root
Check — npx @rqml/cli check validates the schema, coverage, and implementation drift (deterministic, offline)
Develop with your coding agent of choice — it works from the spec, records trace links with rqml link, and you gate CI with rqml check

Tip: Don't write RQML by hand. Your agent drafts it, rqml skeleton keeps the structure valid, and the Claude Code and Codex plugins run the loop for you — anchoring each session on the spec, validating every edit, and gating the turn on rqml check.

Quick start

A complete, valid spec

<rqml xmlns="https://rqml.org/schema/2.1.0"
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xsi:schemaLocation="https://rqml.org/schema/2.1.0
      https://rqml.org/schema/rqml-2.1.0.xsd"
    version="2.1.0" docId="DOC-HELLO-001" status="draft">
<meta>
  <title>Hello World CLI</title>
  <system>hello</system>
</meta>
<requirements>
  <req id="REQ-HELLO-001" type="FR" title="Print greeting"
       status="draft" priority="must">
    <statement>
      The program MUST print "Hello, world!" to standard output
      and exit with status code 0.
    </statement>
  </req>
</requirements>
</rqml>