First judge, then dream.
Governed operational systems for accountable action.
YAI is a native runtime for operational work that must remain accountable as it moves from intention to effect.
The system is built around a simple premise: an action becomes meaningful when it can be situated, judged, executed, recorded, and traced. A command, process, service call, database operation, provider request, file change, agent step, or operator action all cross the same kind of boundary once they begin to produce effects in a machine or toward an external system.
YAI makes that boundary explicit. It brings normative rules, operational context, control, execution, records, state, evidence, and lineage into the same runtime structure.
The lowest reliable point of control is the point where logic touches the machine.
YAI models that point through runtime carriers: native surfaces where operations move from intent into mechanical effect. The control plane mediates those acts through observation, enforcement, evidence, and admission. Governance supplies the normative material: policies, rules, authority, posture, compliance, and evidence requirements become operational constraints rather than detached prose.
A case gives those constraints a perimeter. It defines the work in which an act belongs, the subjects involved, the applicable rules, the state already accepted, and the history that gives the next action meaning.
Above that perimeter, workflows, operators, agents, processes, services, providers, models, databases, files, endpoints, and capabilities can participate in work without dissolving into unrelated steps. The runtime keeps the act attached to context, authority, state, and traceability.
YAI is organized around operational relationships rather than a single interface.
A subject is anything that can participate in an operational chain: an operator, agent, process, service, provider, model, database, endpoint, file, socket, runtime component, or external adapter.
A capability is a governed action surface. It may search, write, query, generate, modify, connect, render, call, or execute, but it enters the system with conditions, targets, side effects, routing, evidence requirements, and admissibility rules.
A case is the executable perimeter of work. It gives actions continuity, scope, state, and responsibility.
Governance materializes normative input into operational constraints. Control applies those constraints before execution. Runtime carries the operation through native boundaries. Records, state, evidence, and lineage preserve what happened, what became true, and how one effect derives from another.
Knowledge and analytics work on this material as derived surfaces. They help the system retrieve, explain, inspect, and reuse operational history while preserving the distinction between accepted state, causal lineage, and derived understanding.
This repository contains the native YAI runtime source tree.
It owns the local runtime implementation, native headers, runtime-facing protocol material, packaging inputs, validation tools, and tests for the core runtime.
YAI is developed across coordinated repositories:
yai/ native runtime
console/ operator and user console, versioned against the runtime
api/ contracts, envelopes, operation projections, compatibility authority
sdk/ developer-facing client packages
web/ account, access, download, and public product surfaces
The runtime package produced from this repository may declare compatibility with
API contract projections and Console versions. Packaging in this repo owns the
yai-runtime payload.
Native runtime implementation lives under src/. Public and internal C headers
live under include/yai/. Protocol material lives under protocols/.
The current source planes include runtime, runtime access, control, governance, case, orchestrator, capabilities, agents, providers, models, state, lineage, knowledge, analytics, and related operating surfaces.
For the canonical source layout, see the root source cutover record.
The Makefile is the local build and validation entrypoint for the native runtime.
make info
make yai
make validate-contractFor a forced native rebuild:
make -B yaiGenerated release artifacts belong under ignored dist/. Packaging source
templates live under packaging/.
packaging/ contains source inputs for building the yai-runtime package:
layout records, payload boundaries, compatibility records, and target-specific
package templates. Generated installable artifacts belong under dist/.
tests/ contains assertions: contracts, boundaries, guards, smoke checks,
integration checks, and harness support.
tools/ contains operational utilities: checks, probes, runtime helpers,
substrate helpers, validation orchestration, and maintenance scripts.
Tests assert. Tools operate, generate, probe, prepare, inspect, or validate.
YAI is under active refoundation and runtime stabilization.
The root layout, source planes, packaging surface, tests surface, and tools surface are now canonical. Current deferred work includes cross-repository vocabulary alignment, serialized compatibility migration, release packaging maturity, and physical memory-plane extraction.
Start here: