Docs

Blueprint format

The Manifest v2 shape that every verified Nemu blueprint must satisfy.

Manifest v2 is the contract

Every blueprint carries an ai-automation/nemu.manifest.json file plus workflow and step documents. The manifest names the blueprint, declares inputs, lists services, orders agent steps, and states the final verification command.

Nemu Blueprint Manifest v2

Rendered from the same MANIFEST_SCHEMA_V2 export used by the validator.

Required manifest fields

schema_version
blueprint
provenance
inputs
services
steps
verify_e2e

Top-level properties

schema_version
blueprint
provenance
inputs
declared_hosts
services
steps
verify_e2e

Raw MANIFEST_SCHEMA_V2 JSON

{
  "$schema": "http://json-schema.org/draft-07/schema#",
  "$id": "https://nemu.ae/schemas/manifest-v2.json",
  "title": "Nemu Blueprint Manifest v2",
  "type": "object",
  "additionalProperties": false,
  "required": [
    "schema_version",
    "blueprint",
    "provenance",
    "inputs",
    "services",
    "steps",
    "verify_e2e"
  ],
  "properties": {
    "schema_version": {
      "const": "2"
    },
    "blueprint": {
      "type": "object",
      "additionalProperties": false,
      "required": [
        "slug",
        "name",
        "category",
        "tags",
        "description",
        "license"
      ],
      "properties": {
        "slug": {
          "type": "string",
          "pattern": "^[a-z0-9]+(?:[-_][a-z0-9]+)*$"
        },
        "name": {
          "type": "string",
          "minLength": 1,
          "pattern": "\\S"
        },
        "category": {
          "type": "string",
          "minLength": 1,
          "pattern": "\\S"
        },
        "tags": {
          "type": "array",
          "uniqueItems": true,
          "items": {
            "type": "string",
            "minLength": 1,
            "pattern": "\\S"
          }
        },
        "description": {
          "type": "string",
          "minLength": 1,
          "pattern": "\\S"
        },
        "license": {
          "type": "string",
          "minLength": 1,
          "pattern": "\\S"
        }
      }
    },
    "provenance": {
      "type": "object",
      "additionalProperties": false,
      "required": [
        "source_repo",
        "author"
      ],
      "properties": {
        "source_repo": {
          "type": "string",
          "minLength": 1,
          "pattern": "\\S"
        },
        "author": {
          "type": "string",
          "minLength": 1,
          "pattern": "\\S"
        },
        "skeletonizer": {
          "type": "string",
          "minLength": 1,
          "pattern": "\\S"
        }
      }
    },
    "inputs": {
      "allOf": [
        {
          "$ref": "#/definitions/inputSchema"
        },
        {
          "type": "object",
          "required": [
            "type",
            "properties",
            "additionalProperties"
          ],
          "properties": {
            "type": {
              "const": "object"
            },
            "properties": {
              "type": "object"
            },
            "additionalProperties": {
              "const": false
            }
          }
        }
      ]
    },
    "declared_hosts": {
      "type": "array",
      "uniqueItems": true,
      "items": {
        "type": "string",
        "pattern": "^(?:[a-z0-9](?:[a-z0-9-]{0,61}[a-z0-9])?)(?:\\.(?:[a-z0-9](?:[a-z0-9-]{0,61}[a-z0-9])?))*$"
      }
    },
    "services": {
      "type": "array",
      "items": {
        "type": "object",
        "additionalProperties": false,
        "required": [
          "id",
          "role",
          "workflow_doc"
        ],
        "properties": {
          "id": {
            "type": "string",
            "pattern": "^[a-z0-9]+(?:[-_][a-z0-9]+)*$"
          },
          "role": {
            "type": "string",
            "minLength": 1,
            "pattern": "\\S"
          },
          "workflow_doc": {
            "type": "string",
            "pattern": "^(?!/)(?![A-Za-z]:)(?!.*\\\\)(?!.*(?:^|/)\\.\\.(?:/|$))(?!.*(?:^|/)\\.(?:/|$))(?!.*//)[A-Za-z0-9._/-]+$"
          }
        }
      }
    },
    "steps": {
      "type": "array",
      "minItems": 1,
      "items": {
        "type": "object",
        "additionalProperties": false,
        "required": [
          "id",
          "file"
        ],
        "properties": {
          "id": {
            "type": "string",
            "pattern": "^[a-z0-9]+(?:[-_][a-z0-9]+)*$"
          },
          "file": {
            "type": "string",
            "pattern": "^(?!/)(?![A-Za-z]:)(?!.*\\\\)(?!.*(?:^|/)\\.\\.(?:/|$))(?!.*(?:^|/)\\.(?:/|$))(?!.*//)[A-Za-z0-9._/-]+$"
          }
        }
      }
    },
    "verify_e2e": {
      "type": "object",
      "additionalProperties": false,
      "required": [
        "command",
        "expect"
      ],
      "properties": {
        "command": {
          "type": "string",
          "minLength": 1,
          "pattern": "\\S"
        },
        "expect": {
          "type": "string",
          "minLength": 1,
          "pattern": "\\S"
        }
      }
    }
  },
  "definitions": {
    "inputSchema": {
      "type": "object",
      "additionalProperties": false,
      "required": [
        "type"
      ],
      "properties": {
        "type": {
          "enum": [
            "string",
            "number",
            "integer",
            "boolean",
            "null",
            "array",
            "object"
          ]
        },
        "title": {
          "type": "string",
          "minLength": 1,
          "pattern": "\\S"
        },
        "description": {
          "type": "string",
          "minLength": 1,
          "pattern": "\\S"
        },
        "properties": {
          "type": "object",
          "propertyNames": {
            "pattern": "^[A-Za-z_][A-Za-z0-9_]*$"
          },
          "additionalProperties": {
            "$ref": "#/definitions/inputSchema"
          }
        },
        "required": {
          "type": "array",
          "uniqueItems": true,
          "items": {
            "type": "string",
            "pattern": "^[A-Za-z_][A-Za-z0-9_]*$"
          }
        },
        "additionalProperties": {
          "const": false
        },
        "items": {
          "$ref": "#/definitions/inputSchema"
        },
        "enum": {
          "type": "array",
          "minItems": 1,
          "items": {}
        },
        "const": {},
        "default": {},
        "examples": {
          "type": "array",
          "items": {}
        },
        "minLength": {
          "type": "integer",
          "minimum": 0
        },
        "maxLength": {
          "type": "integer",
          "minimum": 0
        },
        "pattern": {
          "type": "string"
        },
        "format": {
          "type": "string",
          "minLength": 1
        },
        "minimum": {
          "type": "number"
        },
        "maximum": {
          "type": "number"
        },
        "exclusiveMinimum": {
          "type": "number"
        },
        "exclusiveMaximum": {
          "type": "number"
        },
        "minItems": {
          "type": "integer",
          "minimum": 0
        },
        "maxItems": {
          "type": "integer",
          "minimum": 0
        },
        "uniqueItems": {
          "type": "boolean"
        },
        "minProperties": {
          "type": "integer",
          "minimum": 0
        },
        "maxProperties": {
          "type": "integer",
          "minimum": 0
        }
      }
    }
  }
}

Why this matters

Codex and Claude Code can execute the same recipe without model-specific lock-in.
The registry can reject malformed or incomplete blueprints before users see them.
Docs stay aligned with the validator because the schema below is imported from packages/manifest.

Back to docs