Tools

Use the right Rusl tool at the right boundary.

Installed schemas live at ./.rusl/schemas/<account>/schemas/<schema>.json.

Rusl does not replace your language ecosystem. It resolves the shared contract, vendors it locally, and gives agents the meaning they need before code generation or validation starts.

Install CLI Agent Kit

A starter path

The shortest useful path is CLI install, Agent Kit install, bundle install, then ecosystem code generation and validation.

Install the CLIVendor registry schemas into a project and lock versions.

Install Agent KitTeach Claude Code to query, reuse, request, and contribute.

Add a bundlePull a related package of schemas into the project manifest.

Generate and validateProject the schema into code, then validate at boundaries.

Tool map

Separate dependency work from agent behavior.

This is the important boundary: the CLI vendors contracts; the Agent Kit changes how Claude Code reasons about them.

dependency tool

Rusl CLI

Installs, locks, and vendors schema dependencies from the Rusl registry into your project.

Install CLI

Claude Code plugin

Rusl Agent Kit

Adds the four Rusl agent behaviors and registers the Rusl MCP server automatically for Claude Code sessions.

Install plugin

agent graph access

Bundled MCP server

Exposes search, examples, proposals, endorsements, and annotation writes through the bundled MCP server.

Read MCP guide

ecosystem bridge

Language tools

Use standard JSON Schema generators and validators after Rusl resolves the source contracts.

Generate code

CLI

Install the schema dependency manager.

The CLI installs, locks, and vendors schema dependencies from the registry into your project.

Homebrew

brew install rusl-labs/tap/rusl

macOS and Linux

curl --proto '=https' --tlsv1.2 -LsSf https://github.com/rusl-labs/rusl-cli/releases/latest/download/rusl-installer.sh | sh

Windows

powershell -ExecutionPolicy Bypass -c "irm https://github.com/rusl-labs/rusl-cli/releases/latest/download/rusl-installer.ps1 | iex"

Agent Kit

Install the Claude Code plugin from the marketplace.

The plugin works out of the box. On first project use, it creates the bundle manifest and registers the MCP server for the session.

Claude Code marketplace install

Add the Rusl marketplace, then install the Rusl plugin. No separate MCP configuration is needed.

/plugin marketplace add rusl-labs/rusl-agent-kit
/plugin install rusl

Four skills

The plugin encodes Rusl's expected agent behavior.

/rusl:resolveBefore generating code that touches a structured data shape.

/rusl:reuseBefore hand-authoring a new domain schema.

/rusl:feedbackAfter schema-touching work, using search, endorse, then create.

/rusl:proposalsWhen filing, reviewing, or iterating on schema proposals.

Agent Kit repository

Get schemas

Use a bundle first.

A bundle gives you a useful set of related schemas in one step. Add it once, install it, then generate code from the local files.

Install the feedback schemas bundle.

This installs every schema in the bundle into ./.rusl/schemas. From there, the files are just JSON Schema.

Add and install the bundle

rusl add "rusl/bundles/feedback-schemas"
rusl install
rusl tree

Need setup first?

The getting started guide keeps the CLI, Agent Kit, and project manifest path together.

Setup guide CLI releases

Generate

Bundle one root for quicktype.

The Rusl bundle gets schemas into the configured schema directory. This step prepares one root schema for quicktype; your installed files stay as they are.

Use quicktype for the first pass.

quicktype is the easiest way to see a Rusl schema become useful code in several languages. It works best from one input, so bundle the root schema first and pipe that into the generator.

Install the generator

bun add -d @skriptfabrik/json-schema-bundler quicktype

quicktypestarter path

Generate TypeScript types and a starter parser

Start with ./.rusl/schemas/rusl/schemas/context-request.json. Swap in the root schema your app needs.

quicktype

Bundle and generate

bunx @skriptfabrik/json-schema-bundler --silent \
  ./.rusl/schemas/rusl/schemas/context-request.json |
  bunx quicktype \
    --src-lang schema \
    --lang typescript \
    --runtime-typecheck \
    --top-level ContextRequest \
    --out src/contracts/rusl/context-request.ts

Use the generated code

import { Convert } from "./contracts/rusl/context-request";

const request = Convert.toContextRequest(incomingJson);

quicktype's TypeScript output is a good first parser. Use Ajv at trust boundaries when you need exact JSON Schema validation.

Validate

Generated code is not the contract.

Generated structs and types make app code easier to write. Boundary data still deserves a real JSON Schema validator.

TypeScript / JavaScriptAjv

Ajv

Best default for exact JSON Schema validation in JS runtimes.

bun add ajv ajv-formats

Gosanthosh-tekuri/jsonschema

santhosh-tekuri/jsonschema

Modern draft support and a clean compiler API for local schema files.

go get github.com/santhosh-tekuri/jsonschema/v6

PythonPydantic or jsonschema

Pydantic or jsonschema

Use Pydantic for app models. Use jsonschema when the raw contract is the validator.

uv add pydantic "jsonschema[format-nongpl]"

Rustjsonschema

jsonschema

Validates runtime values against draft 2020-12 JSON Schemas.

cargo add serde_json jsonschema

Java / JVMNetworkNT validator

NetworkNT validator

The usual JVM choice for validating payloads against JSON Schema.

implementation "com.networknt:json-schema-validator:3.0.2"

.NETCorvus.Text.Json.Validator

Corvus.Text.Json.Validator

Good fit when .NET code needs to stay close to JSON Schema semantics.

dotnet add package Corvus.Text.Json.Validator

Elixirex_jsonschema

ex_jsonschema

Compile the installed schema and validate external payloads before mapping into domain structs.

{:ex_jsonschema, "~> 0.2.0"}

Scope

Treat generators as projections.

Rusl gives the shared source of truth. CLI installs, agent context, generated code, and validators are projections around that contract.

Keep the original schema in the loop.

Generated code is useful, but agents and validators should still inspect the original schema, follow refs, read annotations, and request missing context when meaning is ambiguous.

Next steps

Install the CLI, install Agent Kit, add a bundle, then validate real data against the original schema.

Start setup Open agent guide