The metadata standard powering production systems in pharma, education, financial services, secure messaging, and gaming — and the substrate AI coding agents use to keep TypeScript, Java, Kotlin, C#, and Python in lockstep. One metadata model; idiomatic per-language output; conformance-gated across every port.
Enterprise systems have always struggled with the integration tax of 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 accelerate that drift by an order of magnitude. Without a shared spine they regenerate inconsistent boilerplate at every prompt. The pattern is everyone's problem now.
MetaObjects fixes the structural issue rather than the symptoms. Define your domain once in metadata; generate idiomatic code in every language you need; validate that the outputs stay coherent, automatically, across the whole stack. Agents work at the metadata layer — not the regenerated boilerplate — and the codegen plus drift detection guarantees keep five languages in lockstep at enterprise scale.
A metadata-first platform built for production scale — not a code generator bolted onto an IDE. Every pillar ships per-language across the five ports today, gated by shared conformance corpora.
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/JPA, Exposed/KotlinPoet, EF Core/ASP.NET, Pydantic/FastAPI) all driven by the same metamodel.
The model is live, not just at build time. Overlay per-tenant or per-environment metadata to change behavior without redeploying. Add fields, modify validations, alter workflows — at business speed.
Every artifact the platform produces 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.
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.
A small, fused metamodel — eleven base types, composable through inline overlays — describes your domain. The generators take it from there.
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. Five shared conformance corpora — metamodel, render, persistence, API contract, YAML — validate that every implementation agrees on the same semantics down to byte-identical canonical serialization.
# 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 + JPA record DTO (Java) # • Exposed Table + @Serializable data class (Kotlin) # • EF Core entity + ASP.NET routes + DDL (C#.NET) # • SQLAlchemy model + Pydantic + FastAPI (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 ↗
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 — was the day-zero driver for MetaObjects' design choices. 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.
The substrate itself 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.
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.
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.
No competitor exists at MetaObjects' level. Prisma is TS-only. Hibernate is Java-only. EF Core is .NET-only. SQLAlchemy is Python-only. Hand-syncing four separate model definitions across four codebases is the work that ends careers.
One YAML declaration → Drizzle + Zod + Fastify (TS), Spring + JPA + record DTO (Java), Exposed + Spring (Kotlin), EF Core + ASP.NET (C#), SQLAlchemy + Pydantic + FastAPI (Python) — plus migration SQL in every dialect.
Real production systems built on the platform — across pharma, education, financial services, secure messaging, and gaming.
Java / MetaObjects
Customizations per pharmaceutical customer with zero code changes — accomplished by overlaying customer-specific metadata on the base model. Model extensions, UI behaviors, grid layouts, access controls, and validations all reconfigured per tenant by metadata alone.
Java / Salesforce / MetaObjects
Patent-pending secure messaging and digital contract platform, integrated with Salesforce. Built rapidly on MetaObjects — multiple teams shipped in parallel against the same metadata patterns. Dynamic forms, e-signatures, and confidential data exchange, RESTful integration suite throughout.
Java (then) / TypeScript / MCP (now)
Built rapidly on MetaObjects in the early 2000s; the metadata-powered engine survived two decades and now runs FeltBots — the AI poker arena where frontier models compete on the same battle-tested substrate.
Quickstarts, the spec, conformance fixtures, and an llms.txt index for AI coding assistants. Apache-licensed. Open source.
Governance overlays, tenant isolation, compliance instrumentation, professional services, and roadmap for the Enterprise Edition.
Doug runs every commercial engagement personally. Tell us what you're building and we'll tell you whether MetaObjects is the right fit — straight answer, no sales loop.
Email doug@dougmealing.com