Apache 2.0 · Installable in 5 languages — npm · Maven Central · NuGet · PyPI

One shared model of your business. Every system built from it. Every mismatch caught before it ships.

AI now writes a large share of your code, and it writes it one request at a time — with no view of what the rest of your systems already agree on. So the same concept gets described again in the database, the interfaces, the rules and the AI prompts, and the copies quietly stop matching. The usual answer is to give the AI better instructions. Instructions are advisory: nothing stops work when the code no longer follows them. MetaObjects makes the shared model something your build checks — and a mismatch becomes a failed build on a Tuesday rather than an incident in production.

The approach has run in production for over 20 years — pharma regulatory, education content, financial processing, secure messaging and gaming. The unified standard that carries it across TypeScript, Java, Kotlin, C# and Python reached 1.0 on 2026-09-09, with the model format frozen at 1.0. The approach is two decades old; the standard is new and now stable.

Why MetaObjects, why now

AI made our oldest problem urgent.

Large systems have always paid an integration tax for inconsistent models: different teams generating different schemas for the same concept, type drift at every boundary, hand-written mapping code holding it together.

AI coding agents speed that drift up. Without a shared model they regenerate inconsistent boilerplate at every prompt, and the pattern is everyone's problem now.

MetaObjects addresses the cause. Define your domain once in metadata, generate idiomatic code in every language you need, and check automatically that the outputs still match the model. Agents work at the metadata layer instead of regenerating boilerplate, and drift detection keeps five languages in step with the model.

Not sure it fits? Your team can run a free, read-only fit assessment against your own codebase, inside your own AI tooling. Nothing is installed and nothing is shared with me. The report says "not a fit" when that is the answer. How to run it →

See it in two minutes

The business case, in plain terms.

No code, no jargon — what model drift costs you today, and what one shared model changes. For the technical walkthrough, see metaobjects.dev.

Want the technical details? Watch the technical introduction →

What ships

Six pillars, and how far each has shipped.

Each pillar says what ships, in which languages and at what maturity.

Whole-stack codegen

One metadata model produces idiomatic TypeScript, Java, Kotlin, C#, and Python — front-end, back-end, database, API contracts, payload value-objects, output parsers, and migration SQL. Five per-port codegen engines (Drizzle/Zod/Fastify, Spring, Exposed/KotlinPoet, EF Core/ASP.NET, Pydantic/FastAPI) all driven by the same metamodel.

All five languages. The generators are reference code you copy into your repo with eject and own; every one is compiled, and the generated APIs are run, in CI.

Runtime metadata

The model is live, not just at build time. Load the same metadata at runtime to drive CRUD, validation, relationships, and dynamic admin UIs — behavior follows the model, not hand-written plumbing.

TypeScript, Java, Kotlin and Python. C# is on the roadmap.

Drift detection

Every generated artifact is verifiable against the metadata. The same model that powers codegen also catches divergence — between services, between languages, and between human and AI-generated code.

All five languages.

Prompt construction

The prompt is code too — not a string scattered across services. Govern your LLM prompts like the rest of the stack: a typed payload declared as a projection so token-cost bloat is visible, prompt text kept external and provider-resolved, and deterministic rendering that is snapshot-testable, cache-stable, and drift-checked at build time so a renamed field can't silently degrade a prompt. Render + payload-VO + verify + output-parser codegen ship across all five ports today, conformance-gated byte-for-byte. First-party MCP exposure of declared prompts and tools is on the roadmap.

All five languages. MCP exposure on the roadmap.

Requirements and testing

The other four pillars keep the code honest about the model. This one asks whether the thing you said the software does is actually built — an absence no test can fail on, because a test only exercises code that exists. A capability is declared as a node in the same model as your entities, and implementedBy is resolved, not trusted: it names a real member of the real model, so a claim whose implementation was renamed or deleted fails the build instead of going quietly stale, and a claim naming nothing is flagged. meta verify reports the ledger on every run. It proves the links resolve, not that the implementation is correct.

The model in all five languages; the checks run in the Node meta CLI; per-claim test scaffolding is TypeScript-only. Used so far on the maintainer's own products.

Libraries

Design you didn't invent and won't differentiate on — users, groups, roles and grants; a trace of every LLM call — declared once and adopted by name, with the requirements that make it checkable. Adopting one adds no tables until you also opt into its database layer, and a team can copy one into its own repository to own outright.

All five languages, since 1.0.4. The LLM-call library is stable; identity and access is in preview.

How it works

One model, many languages.

A small, fused metamodel — fourteen base types, composable through inline overlays — describes your domain. The generators take it from there.

The metadata is the source of truth.

Schema, validation rules, API surface, persistence mapping, UI hints — all live in the same model. When the model changes, every generated artifact updates from the same root.

The TypeScript-first rebuild ships idiomatic outputs across the JavaScript, Java, Kotlin, C#.NET, and Python ecosystems. Twenty-two shared conformance corpora — metamodel, render, persistence, API contract, YAML — validate that every implementation agrees on the same semantics down to byte-identical canonical serialization.

Read the spec on metaobjects.dev ↗

# metaobjects/meta.subscriber.yaml — the source of truth
metadata.root:
  package: acme
  children:
    - object.entity:
        name: Subscriber
        children:
          - source.rdb:      { "@table": subscribers }
          - field.long:      { name: id }
          - field.string:    { name: email, "@maxLength": 320, "@required": true }
          - field.string:    { name: name }
          - field.enum:
              name: status
              "@values": [active, paused, cancelled]
              "@required": true
          - field.timestamp: { name: createdAt, "@autoSet": onCreate }
          - identity.primary: { "@fields": [id], "@generation": increment }

# From this one file the generators emit:
# • Drizzle table + Zod validator + Fastify routes (TS)
# • Spring @RestController + record DTO (Java)
# • Exposed Table + data class (Kotlin)
# • EF Core entity + ASP.NET routes (C#.NET)
# • Pydantic model + FastAPI router (Python)
# • Per-dialect migration SQL — and the same metadata
#   drives runtime CRUD + drift verification too.

See the full side-by-side output for all five ports at metaobjects.dev ↗

The metamodel goes deep

Fields carry validators, views, and money. Entities derive projections.

The model isn't just columns. Fields hold validators and view hints as child metadata; currency stores integer minor units with locale-aware formatting; and read-only projections derive passthrough fields and aggregates over relationships — generating as database views, not tables. Every snippet below is real meta gen output.

# Child metadata on fields + a derived projection
object.entity: Author
  children:
    - field.string:
        name: email
        children:                                # validators live ON the field
          - validator.required: { name: req }
          - validator.regex:    { name: fmt, "@pattern": "^[^@]+@[^@]+$" }
    - field.currency:
        name: price
        "@currency": USD
        children:
          - view.currency: { name: money, "@locale": en-US }
    - identity.primary: { "@fields": [id] }   # name optional → "primary"

object.projection: AuthorSummary      # derived, read-only
  children:
    - source.rdb: { "@kind": view, "@view": v_author_summary }
    - field.int: { name: postCount, children:
        [ { origin.aggregate: { "@agg": count, "@of": Post.id, "@via": Author.posts } } ] }
// generated/Author.ts — validators become Zod refinements
export const AuthorInsertSchema = z.object({
  email: z.string().min(1).regex(new RegExp("^[^@]+@[^@]+$")),
});

// generated/Post.ts — currency carries Intl config
price: { view: "currency", currency: "USD", locale: "en-US" },

// generated/AuthorSummary.ts — a projection is a VIEW, not a table
export const authorSummaryView =
  sqliteView("v_author_summary", {}).existing();   // read-only, no Insert schema
export const AuthorSummarySchema = z.object({
  postCount: z.number().int(),   // COUNT(Post.id) over Author→posts
});

Loads + generates with zero errors and zero warnings; every construct is conformance-gated across all five ports. Full example at metaobjects.dev ↗

Works with the agents you already use

Designed to be the metadata layer underneath an AI coding agent.

Claude Code, Cursor, GitHub Copilot, Windsurf — the agent doesn't need a plugin. It reads the metamodel from your repo, edits the YAML or JSON definitions, and the codegen handles every language. Drift detection (meta verify) and per-language conformance keep the five generated stacks consistent at every step.

Claude Code in particular — Anthropic's official CLI — has driven MetaObjects' design choices from the first day. Every contract is grep-friendly (named constants, never magic strings); generated code is plain-language-idiomatic, not framework-magic; and an llms.txt index ships at metaobjects.dev/llms.txt ↗ so any agent fluent in that convention can index the full standard in seconds.

AI works best where the source of truth is small, typed, and machine-readable. That's the metadata layer.

MetaObjects is local-first: typed metadata lives in your repo, generated code runs without any MetaObjects dependency at runtime, and the standard is Apache 2.0. If @metaobjectsdev/* disappears tomorrow, you keep working code in every language.

Engineered for verifiable consistency. A cross-language conformance corpus holds every port to byte-identical behavior on the core contract: the metamodel, prompt render and reply parsing, schema and API semantics. Build-time drift detection fails the build the moment generated code, a prompt or a claimed capability diverges from the model, whether a human or an agent wrote the change.

How it compares

A different problem from the ORMs.

Prisma, Drizzle, Hibernate, EF Core, SQLAlchemy — each is excellent in its own language. None of them describe persistence and rendering and tool-calls and validation under one metamodel that emits idiomatic code in every language. None of them give you build-time drift detection across services. MetaObjects fills the gap their single-language scope leaves open.

For a single-language project

If your codebase is one language and not LLM-heavy, the popular ORM in that language is probably enough. Pick Drizzle for TS. Pick JOOQ or JPA for Java. Pick EF Core for C#. Pick SQLAlchemy for Python.

The MetaObjects payoff kicks in when one of three things is true: (a) your codebase spans more than one language, (b) AI coding agents are touching it at volume and drift is the dominant cost of change, or (c) you ship typed prompts and tool-calls that need governance and drift verification.

For a multi-language team

Prisma is TS-only. Hibernate is Java-only. EF Core is .NET-only. SQLAlchemy is Python-only. With those, four codebases mean four model definitions kept in sync by hand.

One YAML declaration → Drizzle + Zod + Fastify (TS), Spring @RestController + record DTO (Java), Exposed + Spring (Kotlin), EF Core + ASP.NET (C#), Pydantic + FastAPI (Python) — plus migration SQL from the shared schema toolchain.

See the full capability matrix on metaobjects.dev ↗

Proof

Powered by MetaObjects.

Real production systems built on this approach over two decades — pharma regulatory, education content, financial processing, secure messaging, and gaming.

Open-source reference implementation

Wizards of Odd

TypeScript / React / MetaObjects

A live AI wizard-council app built to be read: one metadata spine drives the database schema, API types, LLM prompts, and SSE streaming protocol — rename one field and all of them fail in CI. Apache-2.0, clone-and-read.

AI agent platform

Draagon AI

Python / TypeScript / React / MetaObjects

From 17 runtime schema patches to zero: one ~7,000-line YAML spine generates more than 20,000 lines of drift-checked Python and TypeScript — 44 entities and more than 100 LLM prompts declared once, on the published MetaObjects packages.

Voice assistant · the small-adoption case

Roxy

Python / Postgres / MetaObjects

Not every adoption is a rewrite. An existing Python voice assistant took exactly two of the six pillars — prompts rendered from typed payloads at runtime, and Postgres schema owned by the CLI — in about seventy lines of metadata, and left the rest of its codebase alone.

All case studies
Where to next

Open source and contracting

Evaluating MetaObjects for a project?

NIX Solutions can review your architecture, run a pilot or help with migration.

Contract with NIX ↗