completed = falseThe evolving vision
Meaning that can move
Define an application’s entities, relations, operations, and policies once. Use that meaning across databases, APIs, interfaces, and long-running work.
Explore the visionStart with an ordinary application
A todo item is more than a database row
const TodoItem = entity({
name: 'TodoItem',
fields: {
id: field.generated(field.id(), 'uuid'),
list: field.existingRef(TodoList),
title: field.nonEmptyString({ trim: true }),
completed: field.default(field.boolean(), false),
},
})Every item has a stable, generated ID.
The list reference points to another Entity.
Validation and defaults belong to the model.
One model in motion
The same meaning travels through the application
TodoItem.where(completed = false).many()The runtime checks policy and finds the capability that can execute the Read.
Postgres, MySQL, Supabase, or an in-memory implementation preserves the request’s meaning.
The interface does not own a private query language. The database does not become the domain model.
The problem
An application’s meaning is scattered
Every boundary translates the system again. Its intent becomes harder to preserve, inspect, and evolve.
Ontahí today
A shared executable vocabulary
The model survives storage choices, transports, UI frameworks, and execution engines.
Five connected directions
One kernel, a larger field of work
Semantic model
AvailableA shared vocabulary for what an application means and what it can do.
- Entities & relations
- Reads & commands
- Operations
- Conditions & reactions
Distributed execution
In constructionComputations can move without surrendering their meaning to infrastructure.
- Runtime Protocol
- Durable execution
- Observation
- Runtime adapters
Interaction & intelligence
In constructionPeople and models can interpret, complete, and implement typed computations.
- Interactions
- Model interpretation
- Model-backed operations
- Assistants & sessions
Trust & evolution
NextReal applications need authority, continuity, and safe change over time.
- Authorization
- Idempotency
- Model evolution
- Protocol conformance
Languages & surfaces
ResearchOne semantic core can support many ways to author, inspect, and operate a system.
- CLI
- Devtools
- Ontahí languages
- Cross-language portability
Distributed execution
Infrastructure carries the work. Ontahí preserves the meaning.
Runtime implementations may differ. Canonical requests, authority, and lifecycle remain visible across the boundary.
Durable & interactive operations
A computation can pause without losing itself
Interaction belongs to the Operation contract, independent from chat, CLI, Devtools, or a particular workflow engine.
Native model support
Models can occupy two precise roles
Language becomes a canonical request
A model resolves human intent into an existing Read, Command, or Operation. Ontahí still validates, authorizes, and dispatches it.
A model fulfills an Operation contract
The Operation keeps its identity, typed input, output, authority, and lifecycle while composition selects a model-backed executor.
Provider messages never become a parallel operation language.
Trust & evolution
Meaning must remain safe as the system changes
Policies stay attached to semantic actions and data scope.
Identity and idempotency make durable work reliable.
Models, storage, and runtimes need explicit migration paths.
Capabilities and protocol versions need testable contracts.
Research horizon
The Semantic Program Kernel
A computation may be incomplete, travel to the runtime that owns a capability, wait for a participant, and continue as a live value.
An open field of work
Build a runtime, a surface, a language, or a proof
Ontahí provides the grammar. A community can discover what it makes possible.