Angee.AI - Self-Building Agentic SaaS Framework

Challenge

Every team that builds a non-trivial application — SaaS, ERP, or internal tool — eventually re-implements the same dozen cross-cutting concerns: how to authenticate, how to authorize, how to issue stable external IDs, how to audit changes, how to ship files, how to keep secrets, how to expose a typed API, how to do real-time, how to seed data, how to render an admin, how to localize, how to background work, how to talk to third parties. These problems are solved every time, slightly differently, by a different engineer, at every company. The cost is enormous and the surface area for bugs is huge.

‍

Key challenges teams face today:

‍

Boilerplate dominates greenfield development — by the time auth, permissions, audit, and tenancy are wired, the unique product is barely started
AI agents are bolted on after the fact, with no proper identity, audit trail, or permission model — they are second-class citizens of the system
Permission systems are either trivially insecure ("role flag on user") or built from scratch every time, with no consistent contract
Frontends and backends drift: hand-written API clients, mismatched types, runtime errors at the seam
Real-time, background work, and integrations are each solved with a different opinionated library — no coherent surface
"Self-extending" applications — where agents add capabilities at runtime — require infrastructure no off-the-shelf framework provides
Software 3.0 is here: AI agents need to be first-class residents of the system, with declared capabilities, audited actions, and REBAC-addressable principals

‍

Apexive built Angee.AI to collapse this entire cost center into a single opinionated framework — one that is agent-native from day one, treats AI as a first-class participant rather than a bolt-on, and ships a deterministic build pipeline so the framework's promises are mechanically verifiable.

Development Process

Tech Stack

Backend: Python / Django, abstract model composition via Python MRO
Permissions: REBAC (Zanzibar-shape) via django-zed-rebac
Authentication: OIDC (Keycloak, Authentik, Auth0, Google, GitHub), session + token, M2M, agent identities
API surface: GraphQL-first auto-CRUD, custom @query / @mutation / @subscription, REST sidecar (django-ninja)
Real-time: GraphQL subscriptions over WebSocket (channels + daphne)
Frontend: React with headless @angee/sdk (TanStack Form / Table / Virtual / Router + urql)
UI bindings: @angee/ant (antd + ProComponents) and @angee/mantine — proves the SDK is binding-agnostic
Storage: pluggable backends, libmagic MIME detection, signed URLs
Secrets: Fernet-encrypted columns (EncryptedTextField, projection-excluded)
Agent runtime: Go operator daemon, bridged via the operator addon; MCP exposure planned for v1.1
Build tooling: Angee Go CLI for workspaces, dev supervisor, scaffolding, build, migrate
License: MIT (open source)

‍

Framework, Not An App

Angee is a framework, not an app. Used to build SaaS, ERP — which we re-cut as ARP (Agentic Resource Planning) — and personal self-hosted apps. Framework models declare class Meta: abstract = True; concrete tables are emitted, not shipped. Each feature area is a Python package shipping abstract bases that the composer assembles into a concrete Django app. Cross-addon contributions are resolved by Python MRO during angee build — no monkey-patching, no runtime hooks.

‍

Agent-Native From Day One

Apps get a permissioned agent surface via the agents addon — Software 3.0 from day one. Every agent is a first-class principal with declared capabilities, REBAC-addressable identity, audited actions, and per-session grants. Connect Claude, Cursor, or any MCP client directly to your running Angee instance.

‍

REBAC Enforced Everywhere

Every operation passes through a permission backend. anonymous, authenticated, and system roles are framework-reserved. There is no "skip permissions" path — the system is secure by construction, not by convention.

‍

Composer-Driven Build Pipeline

The composer is the only domain that bridges Python and JS. Backend and frontend never reference each other directly; their interface is the typed contract the composer emits. Byte-identical inputs produce byte-identical outputs; CI verifies. No datetime.now(), no uuid4(), no unsorted iteration at build time.

‍

Repo Topology

Angee splits into three repos with distinct ownership:

angee-django — framework + universal SDK + per-addon JS packages (@angee/sdk, @angee/auth, @angee/storage, etc.)
angee/arp — ARP addon set (payments, invoicing, accounting, procurement, CRM, HR) re-cut for the Software 3.0 era
arpee — reference ARP host project composing framework + @angee/arp

‍

Versioning

v1 ships the composer, backend primitives, frontend SDK, and core addons (auth, storage, knowledge, integrate, connect, agents, operator). v1.1 adds the mcp addon (fastmcp-backed tool surface over operator) and workflows addon (queue + scheduled jobs + state machines). v1.3 adds the tenants addon (multi-tenant lifecycles on top of REBAC). Within v1, addons release in lockstep with no backwards-compatibility shims; consumers upgrade the platform as a whole.

Solution

Angee.AI delivers an opinionated, agent-native framework that collapses the cost of building production SaaS from months to days. Teams describe what they need; Angee's agents autonomously scaffold, wire, and deploy production-ready software — APIs, real-time channels, background workers, database migrations — all auto-discovered by the platform.

‍

What Angee decides for you (so you don't have to):

Authorization: REBAC (Zanzibar-shape), schema-driven, identity-agnostic. Every operation passes through it.
Authentication: OIDC with Keycloak / Authentik / Auth0 / Google / GitHub, session + token, with M2M and agent identities first-class
Agent identity: Permissioned, audited, REBAC-addressable agent principals — Software 3.0 from day one
External IDs: Opaque, prefixed, sortable sqids at the API boundary — PKs never leak
Audit trail: Shadow tables per model, opt-in per addon (via django-simple-history)
Files & blobs: Pluggable storage backends, MIME detection via libmagic, signed URLs
Secrets: Per-row EncryptedTextField columns (Fernet at rest, projection-excluded)
API surface: GraphQL-first auto-CRUD from model declarations; custom ops via decorators. REST as optional sidecar.
Real-time: GraphQL subscriptions over WebSocket (channels + daphne); urql on the client
Typed client: Composer emits SDL + TypeScript contracts; graphql-codegen produces typed hooks — no hand-written API client
Seed data: Three tiers — master, install, demo — from explicit YAML/CSV manifests, idempotency in a generated ledger
Admin UI: Auto-emitted from abstract models — the only backend-rendered HTML in the system
i18n: One locale tree per addon serves both Django (.po) and React (.json); namespaced keys
Theming & design system: Tailwind 4 @theme tokens on the active UI binding (@angee/ant or @angee/mantine)
Build determinism: MRO-based composition at build time. Byte-identical inputs → byte-identical outputs; CI verifies.

‍

Already on the roadmap, same contract: workflows (queue + scheduled jobs + state machines, v1.1), mcp (agent tool surface over operator, v1.1), tenants (multi-tenant lifecycles on top of REBAC, v1.3).

‍

Business Impact:

Eliminate months of boilerplate — auth, permissions, audit, storage, secrets, real-time, agents all solved once, consistently
Ship AI agents as first-class principals — every entity permissioned, every workflow agent-addressable
Deterministic builds mean reproducible deployments and trustworthy CI
MIT licensing — no vendor lock-in, full self-hostable
One command install: curl https://angee.ai/install.sh | sh

High Level Features

Self-

Building Applications Describe what you need. Agents autonomously scaffold, wire, and deploy production-ready software — AP Is, real-time channels, workers, migrations — all auto-discovered.

MCP-

Native Agents Every agent is a first-class resident with fine-grained permissions, declared capabilities, and per-session grants. Connect Claude, Cursor, or any MCP client directly.

REBAC

Permissions Zanzibar-shape, schema-driven, identity-agnostic authorization. Every operation passes through it — no "skip permissions" path exists in the system.

GraphQL-

First with REST Sidecar Auto-generated CRUD from abstract model declarations; custom ops via @query / @mutation / @subscription. REST via django-ninja for clients that can't speak GraphQL.

Composer-

Driven Build Abstract Django models compose into concrete runtime apps via MRO. Composer emits typed Type Script contracts; the React SDK consumes them. Byte-identical inputs → byte-identical outputs.

Headless

React SDK@angee/sdk is headless — contracts, hooks, providers, GraphQL wiring. Active binding (@angee/ant or @angee/mantine) ships primitives, Preset Shells, and rendered widgets.

Real-

Time Out of the Box GraphQL subscriptions over Web Socket (channels + daphne) on the backend; urql on the client. Real-time is a first-class contract, not a bolt-on.

Encrypted

Secrets & Audit Trail Per-row Encrypted Text Field ( Fernet at rest, projection-excluded). Shadow tables per model via django-simple-history. Audit by construction, not by convention.

Self-

Hosted or Cloud PostgreSQL with vector search, Redis, real-time streaming, encrypted secrets, full audit trail. Docker deployment — one command either way.

MIT

Licensed & Open Source Entire framework, SDK, and addon ecosystem ship under MIT. Self-hostable, forkable, and free of vendor lock-in.

Get Your Next Project Off the Ground

Want to build your next AI-native SaaS on Angee?

Start Your Project