Ontahí

The 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 vision

Start 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),
  },
})
Identity

Every item has a stable, generated ID.

Relationship

The list reference points to another Entity.

Rules

Validation and defaults belong to the model.

One model in motion

The same meaning travels through the application

01 · InterfaceShow open itemscompleted = false
02 · Ontahí ReadA typed SelectionTodoItem.where(completed = false).many()
03 · RuntimeAuthorize and route

The runtime checks policy and finds the capability that can execute the Read.

04 · AdapterExecute in storage

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

Application meaning scattered around the domainTypes, databases, APIs, permissions, queues, prompts, and UI state each contain a partial translation of the central domain.typespartial modeldatabasestored shapeAPIstransport shapepermissionsaccess rulesqueueswork lifecyclepromptsimplicit intentUI stateinteraction rulesdomainone meaning

Every boundary translates the system again. Its intent becomes harder to preserve, inspect, and evolve.

Ontahí today

A shared executable vocabulary

01Entity
02Relation
03Selection
04Read
05Command
06Operation

The model survives storage choices, transports, UI frameworks, and execution engines.

Five connected directions

One kernel, a larger field of work

01

Semantic model

Available

A shared vocabulary for what an application means and what it can do.

  • Entities & relations
  • Reads & commands
  • Operations
  • Conditions & reactions
02

Distributed execution

In construction

Computations can move without surrendering their meaning to infrastructure.

  • Runtime Protocol
  • Durable execution
  • Observation
  • Runtime adapters
03

Interaction & intelligence

In construction

People and models can interpret, complete, and implement typed computations.

  • Interactions
  • Model interpretation
  • Model-backed operations
  • Assistants & sessions
04

Trust & evolution

Next

Real applications need authority, continuity, and safe change over time.

  • Authorization
  • Idempotency
  • Model evolution
  • Protocol conformance
05

Languages & surfaces

Research

One 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.

01Applicationdeclares meaning
02Runtimeowns capabilities
03Protocolcarries requests
04Another runtimecontinues evaluation

Runtime implementations may differ. Canonical requests, authority, and lifecycle remain visible across the boundary.

Durable & interactive operations

A computation can pause without losing itself

01Invoke
02Progress
03Askchoice · approval
04Resume
05Complete

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

01 · Interpreter

Language becomes a canonical request

A model resolves human intent into an existing Read, Command, or Operation. Ontahí still validates, authorizes, and dispatches it.

02 · Implementation

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

AuthorityWho may do what?

Policies stay attached to semantic actions and data scope.

ContinuityWhat happens twice?

Identity and idempotency make durable work reliable.

EvolutionWhat changed?

Models, storage, and runtimes need explicit migration paths.

ConformanceCan runtimes agree?

Capabilities and protocol versions need testable contracts.

Research horizon

The Semantic Program Kernel

Ontahítyped semantic program
partially binddelegatesuspendobserveresume

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.