100% Open Source and Free

Full-Stack Development Framework for AI Agents Build custom ERP, CRM & Business Tools. Start with 80% job done. Ship in days not months.

Backend ready. Frontend ready. Built-in AI for your product.

Real backend, real UI—one engine for AI. Auth, admin, and multi-tenant basics are already in; you add the product. No months of foundation work.

Ship on your terms. Your repo, your infrastructure—fast, secure, sovereign—not a vendor’s black box.

View on GitHub Live demo ↗ README & docs ↗

Proof, not pitch

You’re not at zero. You’re shipping while others are still hand-wiring auth, tenancy, and admin.

Starting point

~80% ready: stack, APIs, architecture & built-in AI—100% focus on business logic.

  • Orbiteus 80%
  • Supabase-style BaaS 40%
  • Django / Laravel / Node.js 30%

Ship built-in AI with the editors & agents you already use

Logos are trademarks of their owners — shown to illustrate typical workflows, not endorsement.

Quick start 
git clone https://github.com/orbiteus/orbiteus.git
cd orbiteus && docker compose up --build
  • Cursor
  • Claude Code
  • GitHub Copilot
  • Google Antigravity
  • OpenAI Codex
  • Cline
  • Windsurf
  • Kiro
  • Trae
  • Qoder
  • Roo Code

Simple workflow: open the repo in Cursor, VS Code, or Antigravity — your agent reads the same Python + Next.js tree — then wire built-in AI through the action layer and UI hooks.

  1. Use Quick start above for clone + Docker (or follow README for venv + pnpm in admin/).
  2. Point your assistant at README.md, docs/, and orbiteus_core — contracts and layout are grep-friendly.
  3. Extend Actions / ⌘K for built-in AI in the app.

What it is

Ready full-stack engine — backend, frontend, and paths for built-in AI in one repo.

Fast, secure, scalable. Open it in Cursor, Claude Code, Codex, VS Code… and build from 80% done — then layer AI your users actually touch (⌘K, actions, assistants) on the same stack.

  • Full stack — not a vendor login Domain ERP/CRM and internal apps on your code, your host.
  • Backend ready · Frontend ready Tenants, RBAC, auto-API, OpenAPI, schema-driven admin, ⌘K — the spine is there so you can ship built-in AI beside real workflows.
  • Composable, production-minded Extend through modules + contracts — performance, scale, and AI-native product surfaces by design.

Pastes an English instruction for your assistant: use this repo as the engine, read README + architecture docs, run Docker locally, then build your product — including built-in AI surfaces — on top.

Who it’s for

Builders who ship their own product — including built-in AI — on the stack.

Not buyers of a boxed suite — teams that want ownership, a real codebase, and customer-facing AI without a separate bolt-on silo.

  • IT & solo builders One repo you extend — no black-box runtime.
  • Velocity on domain work Fit the workflow in weeks, not a six-month rewrite.
  • Opinionated core Fast, secure, composable — you stay in the domain layer.

Architecture

One spine — registry, tenant-aware data, ActionRegistry.

UI, HTTP API, and in-product AI read the same action definitions — so assistants and automation stay aligned with your domain.

  • Contract-first modules orbiteus_core owns registry, repos, RBAC. Modules: UUID + contracts only — no cross-import maze.
  • Python next to your domain Wire LLM / agent libs in minutes — less glue than many Node.js-first stacks.
  • Same actions everywhere One definition → OpenAPI, /api/*, ⌘K (~1 ms fuzzy match).

ModuleRegistryActionRegistryTenant-scoped repos

Layer diagram & detail →

What we are communicating

01

The system is under active development

Phases 1–2 are done; the frontend, modules, and AI-ready product surfaces are evolving in the open repo — README, issues, forks.

02

Architecture you can rely on

Modules, registry, tenancy, RBAC, and AI-native actions for built-in product AI — documented end to end. Diagrams below, not vague slides.

03

Community comes first

Open source means people: contributors, meetups, hackathons. We want an industry standard — not a solo side project.

Why Orbiteus

You are not buying a tenant on someone else’s SaaS — you are forking an engine and shipping your domain product with built-in AI (what users see in the app, not only what your IDE sees). 80% of the plumbing ships with the repo: multi-tenant data, security, APIs, admin UI from config, and an action layer shaped for AI copilots and assistants.

Python = minutes to AI

Extend the app with LLMs and agents using mature libraries — wire new behaviour in minutes, not a multi-week Node.js↔Python integration project.

80% done on day one

Registry, auto-CRUD, RBAC, tenants, OpenAPI, ⌘K — you implement business rules, UX, and in-app AI, not another auth story from scratch.

Reality check: the point is velocity on custom workflows — days-to-weeks iteration, not quarter-long scaffolding projects — including built-in AI that stays tied to your domain. Want vanilla ERP off the shelf for a tiny shop? Buy a suite. Orbiteus is for ownership and speed on software that fits the business.

Engine · velocity

One spine — from Postgres to admin UI to built-in AI

Illustrative layout: the same contracts power REST, OpenAPI, the renderer, and ⌘K — you extend modules, not another parallel spec.

PostgreSQL

Tenant-scoped data, UUID keys, JSONB where it helps — not a toy store.

Multi-tenant

tenant_id on business tables — repositories enforce scope by default.

RBAC

JWT, roles, record rules — security stays in the core, not scattered in controllers.

Modules

Contract-first registration — no cross-import maze between business packages.

orbiteus_core · layer map
LayerContracts & surface
Admin UINext.js · Mantine · dynamic views · ⌘K
APIFastAPI · auto-CRUD · OpenAPI · /api/ai/actions
CoreModuleRegistry · BaseRepository · Security · ActionRegistry
DataPostgreSQL · tenant_id · Alembic per module

Built-in AI

Actions drive UI, HTTP, and assistants — one definition, fuzzy match in milliseconds.

OpenAPI

Generated contract stays aligned with what the admin and agents actually call.

Admin shell

List, form, kanban from schema — ship screens without hand-writing CRUD pages first.

Your host

Fork the engine — ERP/CRM on your infra, your brand, your roadmap.

From “starting point” to custom CRM / ERP

Illustrative comparison for similar scope — not a third-party benchmark. Bars animate once when this block enters view.

Starting point

~80% ready: stack, APIs, architecture & AI in place—100% focus on business logic.

  • Orbiteus engine 80%
  • Supabase-style BaaS 40%
  • Django / Laravel / Node.js 30%

Typical time to ship

Same class of product—very different time to launch (illustrative)

  • Orbiteus engine ~1.5 weeks
  • Supabase + custom app 3–6 months
  • Framework from scratch 6–12 months

Time bars: longer = faster delivery (Orbiteus normalized to full width).

The engine in practice

Next.js + Mantine — list, kanban, ⌘K, technical modules underneath — the same surfaces you extend for built-in AI in the product. Live demo environment: explore a running deployment at demo.orbiteus.com (demo data only).

Orbiteus CRM: Opportunity kanban view
CRM → Opportunity — view switcher, ⌘K action search (pattern for built-in AI in the UI), Technical section for models and RBAC.

Architecture — layers, flow, contracts

Register a module once → migrations, REST, OpenAPI, admin views, and ⌘K actions stay in sync — one spine from DB to UI to built-in product AI.

  • Isolation: every business table carries tenant_id — the repository applies the filter automatically.
  • Modules: no cross-imports — UUIDs and core contracts only.
  • Built-in AI: every business action is an Action — the same contract powers APIs, UI, and assistants (RapidFuzz in ~1 ms; optional Claude rerank).

What ships in the engine (from the docs)

Core — “80% done”

  • Module registry — plug modules in
  • Auto-CRUD — stop duplicating endpoints
  • RBAC + record rules
  • Multi-tenant isolation
  • OpenAPI contract
  • Command palette / AI action layer — ship built-in AI next to workflows
  • Temporal-ready workflows

Backend

  • Python 3.12+ · FastAPI
  • SQLAlchemy 2 · Alembic
  • PostgreSQL 16
  • JWT + 2FA (TOTP)

Frontend

  • Next.js 14 · React 18
  • Mantine · dynamic UI renderer
  • ⌘K — keyboard-first navigation + AI command surface for the product
  • White-label — your brand

People and community — this is the plan

Orbiteus is not a garage project. MIT open source means transparency, forks, pull requests. We are looking for people who share a vision of technological sovereignty and want business software where AI is built into the product, not duct-taped on the side.

Contributors

Bugfixes, modules, built-in AI integrations — every commit counts. Start from the README, pick an issue, open a discussion.

Meetups

Architecture deep dives, live coding, Q&A — regular online and in-person events planned.

Hackathons

Focused sprints on modules and AI tooling — dates will be announced in the repo and on socials.

“I’m not building this only for myself. I believe in technological sovereignty. Let’s build the standard for next-generation business systems together.”

Repository

Public on GitHub — stars, forks, and license update automatically (Shields.io). The codebase is structured so you can grow built-in AI alongside your domain.

GitHub stars GitHub forks License Last commit
orbiteus / orbiteus

Fork it. Build products with built-in AI. Own your core.

Orbiteus · MIT · github.com/orbiteus/orbiteus

Paste into your IDE

Nothing runs on your machine from this page — you copy the prompt and use it in Cursor, Claude Code, VS Code, or any agent you trust. Safer than deep links or auto-opening apps.