AI integration
High-level languages to capture domain knowledge
Coding agents are changing how software gets built. They work best when what they edit is small, explicit and checkable. Framework-heavy code is none of that: the knowledge of a domain is scattered across layers, and an agent has to guess which parts matter.
Our answer is a high-level language for the domain at hand. It captures the concepts, rules and processes that matter in a compact model: readable for domain experts, verifiable by the language workbench, and writable by agents. Generators turn the model into executable code. The agent does not need to know the technology stack, it works on the level of the domain.
Language workbench plus agent
We build such languages on JetBrains MPS. MPS gives us a projectional editor, type checking and constraints, and generators. For agents we add three things:
Model, not files
Through the MPS MCP integration the agent reads, inserts and validates model nodes. It never touches raw XML or generated code.
- MPS MCP
- Nodes
- Blueprints
- Validation
Skills and documentation
Per language a skill with rules, recipes, reference examples and JSON blueprints, plus staged documentation the agent reads only when a task needs it.
- Rules
- Recipes
- Examples
- Chapter maps
Binding conventions
The modeling standard of a project, so that agents produce consistent models instead of plausible guesses. A project may adjust conventions, an agent never deviates on its own.
- Standard
- Project rules
- Consistency
The result is a loop the language workbench keeps honest: the agent proposes a model, MPS checks it, the build and the tests confirm it.
What we did: MoAI for werkbank
For our own werkbank we built exactly this. Three languages capture business applications: domain logic, persistence and user interfaces. MoAI adds twelve agent skills, four language documents and six convention files, delivered as a Git submodule and agent plugin. Coding agents such as Claude Code now model complete business applications in MPS, and the generators produce a running Java application for desktop, web and mobile. This is how we work in spec-driven development with our customers today.
What we offer
We bring this approach to your domain, drawing on more than 15 years of language design and code generation on JetBrains MPS.
Language design
Together with your experts we design a high-level language on JetBrains MPS that captures your domain knowledge.
Generators
We build the generators for your target platform, so models turn into executable code on the stack you already run.
Agent integration
We integrate coding agents with model access, skills, documentation and conventions, and train your team to work with them.
Agent-ready languages
If you already have your own languages, we make them agent-ready: documentation, skills and conventions that let agents produce correct models.