Glossary

To navigate the ObjectStack ecosystem effectively, it is helpful to understand the specific vocabulary we use. While many terms are standard in computer science, some have specific nuances in our "Protocol-Driven" context.

The Ecosystem

ObjectStack

The umbrella term for the entire suite of protocols and reference implementations. It is organized into 15 protocol namespaces grouped into three architectural layers.

Protocol Namespace

A logical grouping of related schemas and types defined with Zod. ObjectStack has 15 protocol namespaces: Data, UI, System, Automation, AI, API, Identity, Security, Kernel, Cloud, QA, Contracts, Integration, Studio, and Shared.

The Three Architectural Layers

The 15 namespaces collapse into three top-level layers:

Layer	Also called	Namespaces it includes	Purpose
ObjectQL	Data Layer	Data	Objects, fields, queries, relations, validation, data access
Kernel	Control Layer / System Layer (formerly named "ObjectOS")	Kernel, System, Automation, AI, API, Identity, Security, Cloud, Integration, Studio, QA, Contracts, Shared	Runtime, permissions, automation, plugins, tenants, agent tools, artifact loading
ObjectUI	View Layer	UI	Apps, views, dashboards, actions, presentation metadata

Older docs and talks used ObjectOS as the name of this control layer. That name now refers exclusively to the commercial ObjectOS runtime environment (docs.objectos.ai); the open control layer is called the Kernel, described by the System/Kernel/AI/API protocol namespaces below.

The 15 Protocol Namespaces

Data Protocol

Defines the core business data model. Includes Object schema, Field types, Validation rules, Query AST, and Filter conditions. This is the foundation of ObjectQL.

UI Protocol

Server-Driven UI specification for building user interfaces. Includes App structure, Views (List/Form/Kanban/Calendar), Dashboards, Reports, Themes, and Actions.

System Protocol

Infrastructure services including Event Bus, Job Scheduling, Translation (i18n), and Audit Logging. Manages system-level concerns.

Kernel Protocol

Plugin system and runtime management. Includes Plugin lifecycle, Manifest definition, Logger configuration, and Runtime Context. The core of the control layer.

AI Protocol

Artificial intelligence capabilities including AI Agents, RAG pipelines, Natural Language Query (NLQ), Predictive models, Cost tracking, and Orchestration.

API Protocol

External communication layer including REST contracts, API discovery, Realtime subscriptions (WebSocket/SSE), and Routing configuration.

Automation Protocol

Business process automation including Workflows (state machines), Flows (visual logic), and Webhooks (HTTP callbacks).

Identity Protocol

User, organization, and position schemas for identity management.

Security Protocol

RBAC, permissions, policy, and access-control schemas.

Cloud Protocol

Multi-tenant cloud, deployment, environment, and package distribution schemas.

QA Protocol

Test, validation, and quality-assurance schemas.

Contracts Protocol

Cross-package interface contracts shared by runtime packages and services.

Integration Protocol

External system integration schemas and connection metadata.

Studio Protocol

Studio UI metadata and builder-specific schemas.

Shared Protocol

Reusable error maps, suggestions, and metadata normalization utilities.

Architecture Concepts

Protocol-Driven

A development paradigm where logic is defined in static, declarative data formats (JSON/YAML) with Zod schemas rather than imperative code. The goal is to separate the Intent (Business Logic) from the Implementation (Tech Stack).

Local-First (development)

In ObjectStack, "local-first" refers to the development and runtime mode, not data sovereignty on end-user devices. Every project can boot against local drivers (in-memory, SQLite, Turso embedded replica) with zero cloud dependency, so authoring, testing, and demos work fully offline. Cloud is an enhancement, not a prerequisite.

Agent-Ready Boundaries

The architectural commitment that AI agents act only through typed, permission-aware, auditable capabilities derived from the same metadata artifact that powers the application — never via raw SQL, scraped UI state, or hand-written glue tools. RBAC, RLS, and FLS apply to agent actions exactly as they apply to users.

Database Compiler

A system that takes a high-level query AST (Abstract Syntax Tree) and compiles it into an optimized database query string (e.g., SQL). This contrasts with an ORM, which typically acts as a runtime wrapper object.

Virtual Field

A field defined in the Data Protocol schema that does not exist physically in the database table but is computed on the fly.

Example: A SQL subquery or expression injected into the SELECT statement at compile time.

Data & Schema

Object (Entity)

The fundamental unit of data modeling in ObjectStack. Roughly equivalent to a "Table" in SQL or a "Collection" in NoSQL. An Object definition includes Fields, Actions, Triggers, and Permissions.

Driver

An adapter plugin in the Data Protocol runtime stack that allows the Data Layer to communicate with a specific underlying storage engine.

Example (this repo): @objectstack/driver-sql (Postgres / MySQL / SQLite via Knex), @objectstack/driver-mongodb, @objectstack/driver-memory (in-memory, for testing), @objectstack/driver-sqlite-wasm.
Cloud distribution: @objectstack/driver-turso (edge-first SQLite) ships separately, not in this repository.

AST (Abstract Syntax Tree)

The intermediate representation of a query or schema. The Data Protocol parses a JSON request into an AST before the Driver translates it into SQL/NoSQL queries. This allows for security validation and optimization before execution.

Manifest

The entry point configuration file (Kernel Protocol) for an ObjectStack Plugin. It declares dependencies, resources, and extensions using the Manifest schema.

Source (`objectstack.config.ts`)

The authoring form of an ObjectStack app or host: a TypeScript module that calls defineStack() (or composes one with composeStacks()). Source files reference Zod schemas, helper functions and imports — they only run inside the build/dev toolchain. Edit the source when you change what the app is.

Artifact (`objectstack.json`)

The distribution form, produced by objectstack build. A single self-contained JSON document — plus an optional objectstack-runtime.<hash>.mjs sidecar for compiled hooks — that includes the manifest, objects, views, flows and requires: [] capability list. Artifacts are framework-agnostic, deterministic, signable, and the only thing a production runtime actually needs. objectstack start (or any host calling createDefaultHostConfig()) can boot directly from an artifact, with no source files on the target machine.

Interface & Logic

Layout

A JSON structure defined in the UI Protocol that describes the visual arrangement of components. Layouts can be nested and dynamic (e.g., Master-Detail, Grid, Kanban).

Workflow

A business process (Automation Protocol) defined as a Finite State Machine (FSM). It consists of States (e.g., draft, approved), Transitions, and Guards.

Flow

A visual logic automation tool (Automation Protocol) that allows building business processes using a node-based editor. Supports screen flows, autolaunched flows, and scheduled flows.

Action

A discrete unit of logic (UI Protocol) that can be triggered by a user (UI button) or a system event (Workflow transition). Actions define button behaviors and navigation.

Component Registry

A map within the UI Runtime that links a string identifier (e.g., "chart.bar") to a real React Component. This allows the UI Protocol to instantiate UI elements dynamically.

Governance

Tenant (Space / Workspace)

A logical isolation unit in the Cloud Protocol for multi-tenancy, modeled by the tenant schema (cloud/tenant.zod.ts). A single ObjectStack instance can host multiple tenants. Data is segregated by tenant isolation strategies. "Space" and "Workspace" are informal aliases for the same concept.

On this page