Questions teams ask before depending on shared schemas.

So a data shape can be defined once, shared, and versioned — instead of every project redrawing Customer, Address, or Order and paying to reconcile the copies. The argument for that is the manifesto's; Rusl is where it becomes real.

Rusl is where your data schemas live — versioned, shared, and reusable — together with the typed context that explains them. Humans, tools, and agents resolve the same references.

Documentation helps people understand intent, but prose is a weak dependency target. Rusl makes the contract itself explicit: a schema URL can be referenced, versioned, downloaded, installed, annotated, and validated by tools.

A schema is a reusable contract for the shape and validation rules of data. Rusl currently builds on JSON Schema because it is full-featured, battle-tested, and supported across languages. Rusl is not trying to invent a new schema language; it gives schemas a registry, versions, immutable downloads, bundles, annotations, and discovery so they can be reused as shared infrastructure.

A version is an immutable published point in a schema or bundle history. Once a schema version is published, it is available as a cached immutable download, so consumers should depend on explicit versions instead of a mutable idea of latest.

Yes. Published schema versions are durable artifacts. Tools, services, build systems, command-line tools, and agents can cache a versioned download because the content for that version will not be rewritten.

A bundle is a versioned package of schemas. It declares a coherent dependency graph so consumers resolve the same set of contracts instead of assembling a schema set by memory or copy-paste.

An annotation is typed content attached to a subject and validated against its annotation type's schema. People, tools, and agents use them to attach meaning — interpretation, retention, trust, usage — without owning or forking the schema.

A shared shape gets more useful every time someone attaches reliable meaning around it. Annotations are typed — each is validated against its type's schema — so consumers and agents can depend on the shape of that meaning instead of scraping comments.

An annotation type is a name paired with a schema — not itself a schema. The schema validates the content of every annotation of that type, so consumers and agents can rely on its shape.

Schemas should define data shape. Annotations let UI, governance, audit, storage, documentation, and internal policy meanings evolve around that shape without bloating or forking the schema.

Yes. Rusl allows multiple annotations of the same type on one subject. Precedence is a consumer or annotation-type policy, not a global registry rule.

Trust comes from explicit choices: publisher identity, versions, visibility, reuse signals, watchers, favorites, annotation counts, bundle inclusion, and the annotation types a consumer understands.

The Rusl CLI is the schema package manager. A local bundle manifest controls what gets fetched, resolved, and installed into the application directory. From there, schemas can be used by the app, committed according to the project workflow, or fed into generators.

Through the CLI and its embedded MCP server (rusl mcp): agents search, fetch schemas and examples, and write context back — using the same references humans and tools do. The Claude Code Agent Kit wires this up in one step.