---
title: What is ObjectStack?
description: ObjectStack is the AI-native business backend for structured, auditable business applications
---

import { Database, Layout, Cog } from 'lucide-react';

**ObjectStack** is not just a framework; it is an **AI-native business backend protocol** for building enterprise software. It decouples the *Business Intent* (defined as typed metadata) from the *Technical Execution* (handled by the Kernel), so APIs, UI metadata, workflows, and agent tools can all derive from the same source of truth.

## The Problem

In traditional development, application logic is scattered:

1. **Database Schema** (`table.sql`)
2. **Backend Models** (`User.ts`)
3. **Frontend Validation** (`schema.zod.ts`)
4. **API Documentation** (`swagger.json`)
5. **Agent Tools** (MCP definitions, function calls, prompts)

When requirements change, you update code in multiple places. When AI agents need to act, they usually see only brittle glue code or manually curated tools. This is **Implementation Coupling**.

## The Solution

We centralize the "Intent" into a single TypeScript-authored, Zod-validated protocol definition. The implementation layers (React, Node.js, SQL, MCP tools) act as **Runtime Engines** that interpret this protocol.

<Cards>
  <Card
    icon={<Database />}
    title="Data Protocol"
    description="Define business objects, fields, queries, and constraints. Database-agnostic abstraction layer."
  />
  <Card
    icon={<Layout />}
    title="UI Protocol"
    description="Presentation metadata for apps, views, dashboards, and actions."
  />
  <Card
    icon={<Cog />}
    title="System Protocol"
    description="Runtime kernel, plugins, security, automation, audit, and agent boundaries."
  />
</Cards>

## The "Stack" Analogy

Think of ObjectStack as:

- **Kubernetes** for business applications - Declarative configuration over imperative code
- **Terraform** for data modeling - Infrastructure as code, but for data
- **GraphQL + React Server Components** - Schema-driven data + UI rendering combined
- **MCP for business systems** - Structured, permission-aware tools generated from metadata

## Key Features

### 1. Protocol-Driven Architecture

**The UI is a Projection. The API is a Consequence.**

- ObjectUI does not "build" a form; it *projects* the ObjectQL schema into a visual representation
- You do not write endpoints or hand-author every agent tool; ObjectOS *generates* the secure graph based on the access control protocol

### 2. Agent-Ready Boundaries

**Agents act through typed, permission-aware, auditable surfaces.**

- Tool schemas derive from business object metadata
- RBAC, RLS, and FLS apply to agent actions
- Executions are traceable to versioned artifacts, user/org context, inputs, and results

### 3. Database Agnostic

**ObjectQL treats the database as an Implementation Detail.**

- Start with SQLite for prototyping
- Migrate to PostgreSQL for production
- Archive to Snowflake for analytics
- **No code changes required**

## Real-World Benefits

| Traditional Approach | ObjectStack Approach |
| :--- | :--- |
| Write SQL migrations manually | Schema changes sync automatically |
| Build CRUD APIs by hand | REST/GraphQL generated from schema |
| Manually define agent tools | MCP/tool surfaces generated from metadata |
| Duplicate validation logic 3x | Define once, enforce everywhere |
| Lock into one database vendor | Swap databases without code changes |
| Agent tools drift from app logic | Tools derive from the same metadata and permissions |

## Who Should Use ObjectStack?

### Enterprise Developers
Building internal tools, CRMs, ERPs, or admin panels? ObjectStack eliminates boilerplate while making the business model explicit for AI agents.

### Platform Builders
Creating a SaaS product or multi-tenant application? ObjectStack provides enterprise-grade security and isolation.

### Integration Engineers
Connecting multiple systems? ObjectStack's protocol-driven approach makes it easy to map and transform data.

### AI Agent Builders
Need agents to operate real business data? ObjectStack gives them typed schemas, generated tools, permission boundaries, and audit trails instead of brittle query glue.

## Prerequisites

Before you start, make sure you have the following installed:

| Tool | Minimum Version | Check Command |
|:---|:---|:---|
| **Node.js** | 18.0.0+ | `node --version` |
| **pnpm** | 8.0.0+ | `pnpm --version` |
| **TypeScript** | 5.3.0+ | `npx tsc --version` |

<Callout type="info">
**Why pnpm?** ObjectStack uses pnpm workspaces for monorepo management. Install it with `npm install -g pnpm` or `corepack enable`.
</Callout>

## Common Setup Issues

### pnpm not found
```bash
# Install pnpm globally
npm install -g pnpm
# Or use corepack (recommended)
corepack enable
```

### TypeScript version mismatch
ObjectStack requires TypeScript 5.3+. Update with:
```bash
pnpm add -D typescript@latest
```

### Port 3000 already in use
```bash
# Find the process using port 3000
lsof -i :3000
# Kill it or use a different port
PORT=3001 pnpm dev
```

For more troubleshooting, see the [Troubleshooting & FAQ](/docs/guides/troubleshooting) guide.

## Next Steps

- [Core Concepts](/docs/getting-started/core-concepts) — Metadata-driven development & design principles
- [Architecture](/docs/getting-started/architecture) — The three-layer protocol stack
- [Glossary](/docs/getting-started/glossary) — Key terminology
- [Quick Start](/docs/getting-started/quick-start) — Build your first app in 5 minutes
