AI-native enterprise application runtime — model-driven, command-governed, plugin-delivered

Quick Start • Features • Architecture • Docs • Demo • Trust • Feedback • Community

AuraBoot is a runtime layer for complex, long-lived enterprise applications. It is not a CRUD builder, and it is not a packaged ERP — it sits underneath both.

You declare your business in six first-class concepts: Model, Page, Command, Permission, Process, Plugin. The platform turns those declarations into the database schema, the REST API, the rendered UI, the audit log, and — when the operation declares its risk and idempotency — a surface that AI agents can call safely.

Full positioning rationale: docs/getting-started/positioning.md. Architecture: ARCHITECTURE.md.

• Model — entities, fields, relations; drives schema, APIs, default pages
• Page — DSL composition of blocks; business CRUD is contract-rendered, never hand-coded
• Command — the only write path; multi-stage pipeline applies authz, entitlement, validation, state guard, audit, events, side effects
• Permission — five layers: RBAC + ReBAC + organizational scope + ABAC + field-level
• Process — BPMN 2.0 long-running orchestration where each task resolves back to a Command
• Plugin — declared manifest of contributions; industry verticals ship as plugin packages with isolated resources and declared dependencies

Dashboard	Page Designer

Command Pipeline	AuraBot Trace

• Website walkthrough: auraboot.com/demo shows the core model -> page -> command loop.
• PCBA Pilot package: the PCBA manufacturing package is available for scoped design-partner pilots. It is not GA and should not be described as a full ERP replacement.
• Trust posture: auraboot.com/trust documents the current source-available license posture, security contact, and SOC 2 readiness position. AuraBoot does not claim SOC 2 Type I or Type II certification today.

Define models, fields, commands, pages, and formulas in declarative JSON. A single model definition creates the database table, REST endpoints, form validation, and list/detail pages with no code generation step.

Every data operation flows through a unified pipeline: schema validation → permission check → state machine → field mapping → handler → side effects → webhooks → audit. Fully configurable per command through DSL.

• Page Designer — Drag-and-drop page builder with 20+ block types (forms, tables, charts, dashboards)
• BPMN Designer — Visual workflow editor with human tasks, SLA monitoring, and approval routing
• Automation Designer — Event-driven automation rules with triggers, conditions, and actions

• AuraBot — In-app AI assistant for natural language queries, data operations, and guided workflows
• Agent Control Plane (ACP) — Orchestrate AI agents with skills, tools, and memory
• ChatBI — Ask questions about your data in natural language, get charts and tables back
• RAG Knowledge Base — Upload documents (PDF, DOCX, MD, CSV), vector-indexed for AI retrieval
• Multi-LLM — OpenAI, Anthropic, Zhipu GLM, MiniMax, and more through a unified provider interface

SmartEngine-based BPMN 2.0 engine with visual process design, human task assignment, approval inbox, escalation rules, and SLA tracking.

PF4J-based plugin architecture. The OSS repo ships ~20 first-party plugins covering CRM, HR, BPM, asset management, AI / agent control plane, dashboards, and more. Plugins are declarative JSON packages that add models, fields, commands, pages, and menus. Install from a marketplace or build your own with the CLI.

Row-level tenant isolation, role-based access control at resource/operation/data levels, and a complete permission system with menus, routes, and API-level enforcement.

Multi-channel notifications (email, in-app, webhook), event bus for cross-module communication, and webhook dispatch for external integrations.

git clone https://github.com/AuraBootTeam/auraboot.git
cd auraboot
docker compose --profile full up --build -d

The full profile builds and starts PostgreSQL + the Spring Boot backend + the Node BFF/SSR frontend. Cold start takes 2–4 minutes (the backend health check has a 120s start period). Open http://localhost:3000 and log in:

If local PostgreSQL is already using port 5432, keep your local service running and start AuraBoot with a different host port:

POSTGRES_PORT=15432 docker compose --profile full up --build -d

Prerequisites: Java 21+, Node.js 20+, PostgreSQL 15+ (Docker stack ships 16), Redis 7+, pnpm 9+

Start local services first — oss-reset-and-init.sh connects to local PostgreSQL and Redis. Brew/apt-installed services do not auto-start:

The script preflights both endpoints and aborts with a clear message if either is unreachable.

The oss-reset-and-init.sh script handles everything: DB reset, backend startup, /api/bootstrap/setup, frontend startup, plugin import, and storage state generation. Use this for a clean, working environment.

git clone https://github.com/AuraBootTeam/auraboot.git
cd auraboot
./scripts/oss-reset-and-init.sh

When the script exits successfully, the system is fully bootstrapped and both backend (http://localhost:6443) and frontend (http://localhost:5173) are running in the background (logs at /tmp/aura-backend.log, /tmp/aura-web.log, /tmp/aura-bff.log).

Use this when you need to inspect a single layer in isolation — e.g. to attach a debugger to the backend or rebuild plugins without restarting the dev session.

# 1. Reset DB only — backend + frontend stay stopped, /setup wizard handles bootstrap
./scripts/oss-reset-and-init.sh --no-bootstrap

# 2. Start the backend (Spring Boot, port 6443) in a dedicated terminal
cd platform
./gradlew bootRun

# 3. Start the frontend (Vite + BFF, port 5173) in another terminal
cd web-admin
pnpm install
pnpm dev:full

# 4. Open http://localhost:5173/setup in a browser to drive the bootstrap wizard

pnpm dev:full is the default foreground developer entrypoint. If you need the frontend in background mode, run pnpm sync-plugins once and then start pnpm dev:web and pnpm dev:bff separately.

# Backend baseline tests
cd platform
./gradlew test

# AI runtime regression tests (AuraBot / Agent / RAG / Intent)
./gradlew testAi

# Frontend E2E smoke
cd ../web-admin
NO_PROXY=localhost npx playwright test

If you are working on AI features, run both test and testAi. The AI stack lives in core, but its regression suite is split into a dedicated Gradle task so it can run with a heavier test profile without slowing every default backend run.

┌─────────────────────────────────────────────────────────────────┐
│                        Frontend (React)                         │
│  Page Designer │ BPMN Designer │ Automation Designer │ AuraBot  │
└──────────────────────────┬──────────────────────────────────────┘
                           │ BFF (Express)
┌──────────────────────────▼──────────────────────────────────────┐
│                     Spring Boot Backend                         │
│                                                                 │
│  ┌─────────────┐  ┌──────────────┐  ┌────────────────────────┐ │
│  │  DSL Engine  │  │  AI Core     │  │  BPM Engine            │ │
│  │  Model       │  │  AuraBot     │  │  SmartEngine (BPMN)    │ │
│  │  Field       │  │  ACP         │  │  Human Tasks           │ │
│  │  Command     │  │  ChatBI      │  │  SLA Monitoring        │ │
│  │  Page        │  │  RAG / KB    │  │  Approval Inbox        │ │
│  │  Formula     │  │  Multi-LLM   │  │                        │ │
│  └──────┬──────┘  └──────────────┘  └────────────────────────┘ │
│         │                                                       │
│  ┌──────▼──────────────────────────────────────────────────┐   │
│  │              20+ Stage Command Pipeline                  │   │
│  │  LOAD → VALIDATE → PERMISSION → STATE → LOCK → HANDLER │   │
│  │  → EFFECT → SIDE_EFFECT → WEBHOOK → AUDIT → COMPLETED  │   │
│  └─────────────────────────────────────────────────────────┘   │
│         │                                                       │
│  ┌──────▼──────┐  ┌──────────────┐  ┌────────────────────────┐ │
│  │  Plugin FW  │  │  RBAC        │  │  Notification          │ │
│  │  (PF4J)     │  │  Multi-Tenant│  │  Email/Webhook/In-App  │ │
│  └─────────────┘  └──────────────┘  └────────────────────────┘ │
└──────────────────────────┬──────────────────────────────────────┘
                           │
              ┌────────────▼────────────┐
              │  PostgreSQL  │  Redis   │
              └─────────────────────────┘

auraboot/
├── platform/                 # Spring Boot backend
│   └── src/
│       ├── main/java/        #   Application source
│       └── test/java/        #   Integration tests
├── web-admin/                # React frontend + BFF
│   ├── app/                  #   Application source
│   └── tests/                #   E2E and API tests
├── plugins/                  # Plugin packages (~20 first-party in OSS repo)
│   ├── crm/                  #   CRM plugin
│   ├── sales/                #   Sales management
│   ├── procurement/          #   Procurement
│   └── ...
├── docs/                     # Documentation (54 files)
│   ├── getting-started/      #   Quick start and tutorials
│   ├── core-concepts/        #   DSL, models, commands, pages, permissions
│   ├── guides/               #   Feature how-to guides
│   ├── use-cases/            #   15 industry solution walkthroughs
│   ├── plugin-development/   #   Plugin development guides
│   ├── api-reference/        #   REST API documentation
│   ├── deployment/           #   Docker, K8s, configuration
│   └── architecture/         #   System design and data model
├── scripts/                  # Build, seed, and CI scripts
├── docker/                   # Docker configuration
└── docker-compose.yml        # One-command infrastructure

Full Documentation →

• Introduction — What is AuraBoot, who it's for
• OSS Onboarding — Clone, bootstrap, and smoke-test the community edition
• Open-Source Scope — What is and isn't OSS, how to verify, how to adjust scope
• Quick Start — Docker Compose setup in 5 minutes
• Installation — Detailed installation guide
• Build Your First App — 30-minute tutorial

• DSL Engine — Declarative configuration philosophy
• Models & Fields — 22 field types, relations, formulas
• Commands — 20+ stage pipeline reference
• Pages & Layouts — Page kinds, blocks, designers
• Permissions — RBAC, multi-tenant, data-level security
• State Machines — Status flows and transitions

• CRM — Customer relationship management
• Project Management — Projects, tasks, Gantt charts
• Sales — Pipeline, quoting, orders
• Procurement — Purchase orders, supplier management
• Manufacturing — Production planning, BOM, MRP
• Warehouse — Inventory, WMS, stock management
• Finance — Invoicing, AP/AR, tax compliance
• And 8 more →

• Plugin Development — Build plugins with JSON, Java, or React
• API Reference — REST APIs, commands, data sources, webhooks
• Deployment — Docker, Kubernetes, configuration
• Architecture — System design and tech stack

For enterprise licensing, use the AuraBoot contact form.

• Website feedback form — Product feedback, beta issues, licensing questions, and private notes
• GitHub Discussions — Ask questions and share ideas
• GitHub Issues — Report bugs or request features
• Discord — Community chat only; use the website form for feedback that needs follow-up

We welcome contributions of all kinds — bug fixes, features, documentation, and plugin development. See CONTRIBUTING.md for the development setup, coding standards, and PR process.

To report a security vulnerability, please email security@auraboot.com. Do not open a public issue. See SECURITY.md for our full security policy.

AuraBoot is released under the AuraBoot License v1.3, a source-available license based on Apache 2.0 with supplementary terms:

• Free for internal use — Use, modify, and deploy for your own business applications. No obligation to open-source your modifications.
• Free for ISV / project delivery — Build and deliver business applications (ERP, CRM, vertical SaaS) to customers, with your changes kept private.
• Attribution required — Retain copyright notices, license notices, and AuraBoot brand information.
• Platform restriction — You may not offer AuraBoot itself as a hosted low-code / no-code / AI platform service without a commercial license.

📖 See the License FAQ (中文) / License FAQ (English) for common questions about commercial use, modification, redistribution, and SaaS boundaries.

For commercial licensing (multi-tenant low-code SaaS, white-labeling, or removing branding), use the AuraBoot contact form.

Built with care by the AuraBoot Team