RuslThe Schema-Driven Development platform

A registry for shape.A layer for meaning.

We version our code. We reinvent our data shapes — and agents made the cost impossible to ignore. They fail at agreement, not syntax. Rusl is where that agreement lives: versioned shape, typed meaning, resolved by your agents.

shape · one authoremail: string
meaning · many authorsmask in logs @platformkeep 30d @billingtrust: endorsed @data
point your agent at your own repo

Prove it.

Your codebase has five definitions of User. Your agent wrote four of them.

Point your agent at your own codebase and see the schemas you already have but can't see. Read-only — just a report.

read-only · nothing changed
prompt · paste into your coding agent
Fetch https://rusl.com/llms.txt to learn the schema-driven standard and what Rusl provides. Then explore this repo read-only — don't create, edit, or generate anything. This is a map, not a migration.

Find the schemas I already have but can't see: the data shapes that live in the code with no single declared definition.

1. Defined more than once — the same shape (say, a User, an Address, or an Order) redeclared across types, validation, database models, API payloads, and the context I hand my agents — each copy a little different.
2. Crossing boundaries — structures that travel between UI, validation, storage, and agent context with no one place that says what they are.
3. Re-invented by agents — definitions a coding agent keeps guessing at because nothing authoritative exists to resolve.

For each, also find where its meaning lives — which fields are PII, how long they're kept, what a status like inactive really means, which source to trust — and whether that's written anywhere an agent could resolve, or only in someone's head.

Report an inventory: name each hidden schema, list every place it's redefined, and show where the copies have drifted. Then, using what you learned from Rusl, identify where each of Rusl's two layers would help — call them out separately:
- Schema registry — where one shared, versioned definition would replace the drifting copies your agents keep reinventing.
- Context layer — where typed context would capture the meaning that's currently unwritten (PII, retention, what inactive means, which source to trust), so an agent can resolve it instead of guessing.

Rank by how much adopting both would remove. Change nothing. Then ask me: "Want to make this repo schema-driven with Rusl?"

Vibe-code the code. Never vibe-code the data.

For your build and your agents

Pull it into your build. Resolve it from your agent.

Rusl reaches you the way you already work — a package manager for your schemas, an embedded MCP server for your agents.

A package manager for schemas

Declare your dependencies, run rusl install, and a fully-resolved, versioned set lands in ./schemas — locked and reproducible. Reuse what's proven, in your codebase or on Rusl, instead of your agent hallucinating the 400,001st variant of Address.

rusl.bundle.toml — declare what you depend on
[rusl.resources]
"acme/bundles/payments" = "~>1.2"
$ rusl install✓ resolved 12 schemas · locked in rusl.lock · vendored to ./schemas

Typed context your agent resolves mid-task

Your agents have no shared memory across sessions, and your team has no shared context window. A schema is the single place that agreement can live — versioned, attributable, resolvable. The CLI carries an embedded MCP server, so your agent resolves meaning mid-task and writes back what it learns in the same session.

On the other end isn't a wiki — it's typed context, with provenance and review. The agent kit drops four moves into Claude Code — resolve, reuse, feed back, propose — so reaching for Rusl is the lazy move.

Install the agent tooling
I loved the contracts, not the format.

Fourteen years of strong schemas — Square, Opendoor, Zod. Every time, the same hole: everyone knew the shape, not everybody knew what it meant.

Why I built Rusl
The context layer

Separate shape from meaning.

Shape has one author. Meaning has many.

Rusl is where the meaning lives — as annotations: typed context attached to a schema. Each is validated against its annotation type (a name + a schema), so your context stays structured and queryable, not prose in a README.

What the layer carries
Whatever the community defines — for example:
Interpretation — what a field really means, agreed once.
Masking — which fields to redact in logs, per team.
Retention — how long to keep a field; your policy and mine.
Trust — which source to believe, endorsed by a peer.
Migration — what changed across versions, and how to move.
Open by design

The context layer is open.

The context layer's vocabulary isn't Rusl's to define — it's yours. "Meaning has many" means many kinds, not just many authors: anyone can coin an annotation type — a name and a schema for a kind of meaning no one's named yet — and attach annotations of it to a schema or a bundle. PII, retention, trust, display rules. Rusl authors a few of its own, but only as one member, not the authority.

A kind of meaning — a name and a schema:
{
  "id": "quality-labs/annotation-types/freshness-policy",
  "schema": {
    "required": ["staleAfterDays", "onStale"],
    "properties": {
      "staleAfterDays": { "type": "integer" },
      "onStale": { "enum": ["warn", "refetch", "reject"] }
    }
  }
}
coined by quality-labs — not Rusl
An annotation of that type, on a schema:
{
  "type": "quality-labs/annotation-types/freshness-policy",
  "subject": "acme/schemas/customer",
  "author": "billing",
  "content": { "staleAfterDays": 30, "onStale": "refetch" }
}
attached by billing — not the schema's author

Rusl defined none of it. quality-labs coined the type; billing attached it; the schema's author never anticipated either — and didn't have to. That's what makes the context layer a commons, not a registry.

Open means billing and legal can attach contradictory policies. Unchecked, that's noise — too many annotations and trust becomes unresolvable. The mechanism that holds it is provenance: every annotation carries an author. Review sorts them. Endorsements from people you trust surface the ones that hold. Not one blessed truth — a resolvable one.

Ships with Rusl

Real context you can attach today.

Rusl ships the feedback bundle — a starter set of context types for describing any schema: its meaning, its usage, the graph of what it links to, whether to trust it. Attach them to your own schemas the moment you install — published the same way you'd publish your own.

A few of the types it ships
domain-interpretationtrust-signalusage-reportmigration-guidesource-attestationsemantic-link

The bundle's manifest is the canonical list — and it grows.

Browse the bundle
Table stakes

A registry. Then the layer that matters.

A registry answers one question: is this payload the right shape? That's table stakes — versioned, collaborative, public or private. What it doesn't carry is what actually drifts: what a field means, who decided, whether you should trust them. Rusl is a registry, then it builds the context layer on top — the typed meaning your agents can actually fetch.

Bundles group schemas, so you're not hand-picking one at a time. Use a published bundle and get every schema in it — pinned and resolvable together.

versioned · semverproposals & reviewpublic + privatediscoverable
bundle

acme/bundles/payments

Invoice
Payment
Customer
Refund
rusl add acme/bundles/payments

install one → get all four

Six principles, one product

The Schema-Driven Development platform.

We value a resolved definition over a convenient local copy, deciding the shape over writing the code, one shape with many authors of its meaning over one owner of both, versioned disagreement over silent drift.

You decide the data
Declare it once — one schema, one home.
Reuse before reinventing — resolve what's proven.
Propose before you generate — review, then build.
Rusl handles the rest
Versions it like code — immutable semver, proposals, diffs.
Everything derives from it — types, validators, forms, docs.
Carries its meaning — the context layer.
customer.schema.json
typesvalidatorsformsOpenAPIdocsagent context

Decide one schema; the rest is a build artifact — derived from the one definition, regenerated on every change. You author the meaning; the plumbing derives.

Decide what things are. Generate the rest.

We version our code. Why not the meaning it depends on? The manifesto makes the full case.