The AI-native business backend: define business objects, permissions, workflows, APIs, UI metadata, and agent tools once as structured Zod metadata.

ObjectStack is a metadata-driven backend for building business applications that AI agents can understand, operate, and audit safely.

Instead of hiding business logic inside ad-hoc SQL queries, UI state, or JavaScript strings, ObjectStack makes the business system explicit:

• Business objects are Zod schemas with typed fields, relations, validation, and permissions.
• Business actions are generated from metadata as REST APIs, SDK calls, and MCP tools.
• Business logic is represented as analyzable metadata: flows, conditions, policies, and artifacts.
• Business runtime is a microkernel that loads plugins, drivers, services, and compiled project artifacts.

The goal is not to be another low-code UI builder. ObjectStack is the structured execution layer for AI-native business software: agent-ready, permission-aware, versioned, and auditable.

ObjectStack is built around three protocol layers:

• ObjectQL (Data Layer) — Objects, fields, queries, relations, validation, and data access.
• ObjectOS (Control Layer) — Runtime, permissions, automation, plugins, tenants, and artifact loading.
• ObjectUI (View Layer) — Apps, views, dashboards, actions, and presentation metadata.

All core definitions start with Zod schemas (1,600+ exported schemas across 200 schema files). TypeScript types, JSON Schemas, REST routes, UI metadata, and agent tools are derived from the same source of truth.

See ARCHITECTURE.md for the full microkernel and layer architecture documentation, and content/docs/concepts/north-star.mdx for the product north star (Studio · Org/Project/Branch · per-project ObjectOS · compiled app artifacts).

• Built for AI, not retrofitted — Business objects, permissions, flows, APIs, and UI are declared as typed metadata, not hand-written. A typical enterprise module collapses from tens of thousands of lines of CRUD/glue into a few hundred lines of declarative schema — roughly two orders of magnitude less code, small enough for an AI agent to load end-to-end and safely refactor across data, API, UI, and permissions in a single change.
• Agent-ready metadata — Business objects, actions, and permissions are explicit enough for AI agents to inspect and use.
• Automatic tool surface — Metadata can power REST APIs, client SDKs, UI views, and MCP tools without redefining each action by hand.
• Protocol-first schemas — All schemas are defined with Zod; TypeScript types are derived via z.infer<>.
• Versioned JSON artifacts — TypeScript-authored metadata compiles into deployable, self-describing JSON artifacts.
• Microkernel plugin system — DI container, EventBus, and lifecycle hooks (init -> start -> destroy).
• Multi-database support — In-memory, PostgreSQL, MySQL, SQLite, and Turso/libSQL drivers.
• 7 framework adapters — Express, Fastify, Hono, NestJS, Next.js, Nuxt, SvelteKit.
• Client SDK + React hooks — useQuery, useMutation, usePagination out of the box.
• Built-in authentication — better-auth via plugin-auth.
• RBAC / RLS / FLS security — Role-based, row-level, and field-level access control.
• Automation engine — DAG-based flows, triggers, and workflow management.
• AI service — Agent, Tool, and Skill protocol built on the Vercel AI SDK.
• Studio IDE — Web-based metadata explorer, schema inspector, API console, and AI assistant.
• CLI toolchain — os init, os dev, os studio, os serve, os validate, and more.

Built for AI, not retrofitted.

Most internal-tool and low-code platforms were designed for humans clicking screens. AI support is usually added later as a chat box that can call a few predefined queries. ObjectStack starts from a different assumption: AI agents need a structured, bounded, and auditable business backend before they can safely perform real work — and the entire business system has to be small enough to fit in an agent's context window.

A typical enterprise application is tens of thousands of lines of CRUD, forms, queries, permissions, and API glue spread across dozens of files. ObjectStack collapses the same surface into a few hundred lines of typed metadata — roughly two orders of magnitude less code for a developer (or an AI agent) to read, write, and maintain.

The point isn't lines of code. The point is fit in an agent's context window. When the entire business system is small, typed, and declarative, an AI agent can load it end-to-end, reason about every dependency, and safely refactor across data, API, UI, and permissions in a single change. That turns AI from an autocomplete tool into a real co-maintainer of production business software.

This makes ObjectStack a backend substrate for AI-native business applications: CRM agents, support agents, operations agents, workflow agents, and internal tools that must act on real business data without bypassing permissions or audit trails.

# Create a new project
npx create-objectstack my-app
cd my-app

# Start dev server (REST API + Studio IDE)
pnpm dev
# → API:    http://localhost:3000/api/v1/
# → Studio: http://localhost:3000/_studio/

Alternatively, with the CLI installed: os init my-app && cd my-app && os dev.

# 1. Clone and install
git clone https://github.com/objectstack-ai/framework.git
cd framework
pnpm install

# 2. Build all packages
pnpm build

# 3. Run tests
pnpm test

# 4. Start Documentation site
pnpm docs:dev
# → http://localhost:3000/docs

The CLI binary ships as both os and objectstack.

os init [name]    # Scaffold a new project
os create         # Interactive project / object scaffolder
os dev            # Start dev server with hot-reload (REST + Studio)
os studio         # Open the Studio IDE
os start          # Start the production server
os serve          # Serve a compiled artifact
os compile        # Build a deployable JSON Project Artifact
os validate       # Validate metadata against the protocol
os lint           # Lint metadata for best-practice violations
os info           # Display project metadata summary
os generate       # Scaffold objects, views, flows, agents, migrations
os doctor         # Check environment health
os explain        # Explain protocol concepts on the command line

Cloud, package registry, and project management subcommands (os projects, os publish, os login, os whoami, os cloud …) are available when targeting an ObjectStack Cloud control plane.

ObjectStack uses a microkernel architecture where the kernel provides only the essential infrastructure (DI, EventBus, lifecycle), and all capabilities are delivered as plugins. The three protocol layers sit above the kernel:

┌─────────────────────────────────────────────────────┐
│              ObjectKernel (Core)                     │
│  ┌───────────────────────────────────────────────┐  │
│  │  Plugin Lifecycle Manager                     │  │
│  │  • Dependency Resolution (Topological Sort)   │  │
│  │  • Init → Start → Destroy Phases              │  │
│  └───────────────────────────────────────────────┘  │
│  ┌───────────────────────────────────────────────┐  │
│  │  Service Registry (DI Container)              │  │
│  │  • registerService(name, service)             │  │
│  │  • getService<T>(name): T                     │  │
│  └───────────────────────────────────────────────┘  │
│  ┌───────────────────────────────────────────────┐  │
│  │  Event Bus (Hook System)                      │  │
│  │  • hook(name, handler)                        │  │
│  │  • trigger(name, ...args)                     │  │
│  └───────────────────────────────────────────────┘  │
└─────────────────────────────────────────────────────┘
              │
    ┌─────────┴─────────┬──────────┬──────────┐
    │                   │          │          │
┌───▼────┐      ┌───────▼──┐   ┌──▼───┐  ┌───▼────┐
│ObjectQL│      │  Driver  │   │ Hono │  │  App   │
│ Plugin │      │  Plugin  │   │Server│  │ Plugin │
└────────┘      └──────────┘   └──────┘  └────────┘

See ARCHITECTURE.md for the complete design documentation including the plugin lifecycle state machine, dependency graph, and design decisions.

See ROADMAP.md for the planned phases covering runtime hardening, framework adapter completion, developer experience improvements, performance optimization, and security hardening.

Studio-specific roadmap: apps/studio/ROADMAP.md

We welcome contributions. Please read CONTRIBUTING.md for the development workflow, coding standards, testing requirements, and documentation guidelines.

Key standards:

• Zod-first — all schemas start with Zod; TypeScript types are derived via z.infer<>
• camelCase for configuration keys (e.g., maxLength, defaultValue)
• snake_case for machine names / data values (e.g., project_task, first_name)

Full documentation: https://docs.objectstack.ai

Run locally: pnpm docs:dev

Apache 2.0 © ObjectStack