Conflux Stack

Platform
Pricing
docs

Offline-first application platform

The Application Development Framework for AI and Humans.

An offline-first application platform for building AI-native business software. Conflux compensates for uneven technical depth on your team — a junior developer, a senior engineer, and an AI agent each produce the same standard output. One connected stack, less plumbing, more building.

Get startedDocumentationSource on GitHub

One platform · native modules

Offline-first

Your app

Auth

Sync

Database

Queue

Comms

AI

SDK

UI

31 modules · one SDK · one path each

Full registry

01

Why Conflux

Business software needs a complete platform

Teams building AI-native business applications spend months wiring together auth, data sync, queues, communications, and operations tooling. Conflux Stack provides every layer through one opinionated platform with one consistent interface.

Conflux is not a collection of packages you choose from. It is a single platform where consistency matters more than configurability. Every module follows the same naming conventions, configuration patterns, and TypeScript types.

One auth and authorization model across every app

Offline-first sync built into the data layer

Runtime services that share observability and tenancy

Communications and notifications as primitives

02

Standard implementation

One canonical way to implement every capability

Whether the author is a junior developer, a senior developer, or an AI agent, every Conflux capability is implemented the same way and produces the same standard output.

The Twilio model

When two developers integrate Twilio OTP, they cannot each invent their own approach. Twilio defines the API, the flow, and the expected behavior. Conflux applies that same constraint across auth, sync, queues, communications, and every other platform layer. The platform compensates for uneven technical competency on the team — implementation variance is removed, so author skill affects speed, not output quality.

Capability examples

02.01

Auth · OTP

Sign in a user with a one-time code sent to their phone

Identity & Security

Three authors · three implementations

Developer A

// custom route + session store
await fetch("/api/send-code", { body: phone });
req.session.otp = generateCode();

Developer B

// third-party SDK, different flow
await supabase.auth.signInWithOtp({ phone });
// no shared session shape with rest of app

AI agent

// invents a one-off pattern
const token = await verifyPhoneNumber(auth, phone);
localStorage.setItem("otp_token", token);

One Conflux path · every author

SDK

await conflux.auth.sendOtp({ to: phone });
await conflux.auth.verifyOtp({ code });

CLI

conflux auth otp:enable --channel sms

Config

conflux/auth.config.ts

02.02

Sync

Keep orders available offline and sync when connectivity returns

Data Layer

Three authors · three implementations

Developer A

// IndexedDB + manual merge logic
const db = new Dexie("orders");
await db.orders.put(order);
// custom conflict resolver per field

Developer B

// cache-only, no true offline writes
const { data } = useQuery(["orders"], fetchOrders,
  { staleTime: 60_000, retry: 3 });

AI agent

// fragile local persistence
const orders = JSON.parse(
  localStorage.getItem("orders") ?? "[]"
);

One Conflux path · every author

SDK

const { data, mutate } = useSync("orders");

await mutate.create({ customerId, total });

CLI

conflux sync:schema push

Config

schema/orders.conflux.ts

02.03

Queue

Send an invoice email after an order is placed

Runtime Layer

Three authors · three implementations

Developer A

// fire-and-forget in the request handler
sendInvoiceEmail(orderId).catch(console.error);
// lost if process restarts

Developer B

// separate infra, separate conventions
await invoiceQueue.add("send", { orderId },
  { attempts: 3, backoff: 5000 });

AI agent

// scheduled inside API route
setInterval(async () => {
  await db.query("SELECT * FROM pending_invoices");
}, 30_000);

One Conflux path · every author

SDK

await conflux.jobs.list({ status: "failed" });
// platform enqueues webhook/cron/prune jobs

CLI

conflux doctor  # queue pressure; Console Queues for retry

Config

# jobs come from webhooks, cron, retention — not app enqueue

02.04

Communications

Notify a user that their invoice is ready

Communication Layer

Three authors · three implementations

Developer A

// inline SMTP, HTML string in handler
await transporter.sendMail({
  to: user.email,
  subject: "Invoice",
  html: `<p>Hi ${user.name}...</p>`,
});

Developer B

// vendor SDK + hardcoded template id
await sgMail.send({
  templateId: "d-abc123",
  to: user.email,
});

AI agent

// webhook to unknown endpoint
await fetch(process.env.EMAIL_HOOK, {
  method: "POST",
  body: JSON.stringify({ user, invoice }),
});

One Conflux path · every author

SDK

await conflux.communications.send({
  channel: "email",
  template: "invoice-ready",
  to: user.email,
  data: { invoiceId },
});

CLI

conflux comms:template push invoice-ready

Config

templates/invoice-ready.conflux.html

One SDK method, one CLI command, one config shape per capability

Generated and hand-written code follow identical patterns

Code review focuses on business logic, not integration style

AI agents and junior developers produce senior-equivalent integration code

Onboarding does not depend on who previously built similar features

03

Platform

Nine layers, one stack

One cohesive platform from identity through operations. Each layer builds on the ones below it — not a menu of packages you assemble yourself.

How layers compose

Identity secures access. Data persists and syncs offline. Runtime executes background work. Communications reach users. Intelligence and automation operate on shared primitives. Integration exposes the platform outward. Experience delivers the UI. Operations govern tenancy, observability, and lifecycle — across every layer above.

Layers

9

Capabilities

31

Available now

22

Sync model

Offline-first

01

Identity & Security

Authentication, authorization, secrets, and audit for business applications.

4 modules

4 live

AuthAuthorizationSecretsAudit

02

Data Layer

Schema, database, sync, storage, and search — offline-first by design.

5 modules

5 live

SchemaDatabaseSyncStorageSearch

03

Runtime Layer

Realtime, queues, functions, and scheduled jobs.

4 modules

4 live

RealtimeQueueFunctionsCron

04

Communication Layer

Outbound channels and in-app notification center.

2 modules

1 live

CommunicationsNotifications

05

Intelligence Layer

Analytics, AI, and autonomous agents.

3 modules

1 live

AnalyticsAIAgents

06

Automation Layer

Workflows and business rules.

2 modules

WorkflowRules

07

Integration Layer

Webhooks, public API, and SDK.

3 modules

3 live

WebhooksPublic APISDK

08

Experience Layer

UI components and extensibility.

2 modules

1 live

UIExtensions

09

Platform Operations

Tenant management, observability, and lifecycle operations.

6 modules

3 live

Feature FlagsTenant ManagementObservabilityImport & ExportBackup & RestoreVersioning

Every capability has a planned status, description, and canonical integration path in the full platform registry.

Full capability map

04

Built for AI

Same standard output, every author

AI agents do not guess how to wire auth, sync, or queues. Conflux exposes one canonical integration path per capability — the same path a senior developer would choose, encoded into the SDK and CLI.

Canonical SDK paths

One function signature per capability — agents never invent alternative integration patterns.

Deterministic structure

Monorepo layout, package naming, and config locations never vary between projects.

Typed interfaces

Strict TypeScript across SDK, schema, and API boundaries.

Registry-driven platform

Capabilities are declared in machine-readable config, not scattered across docs.

CLI-first operations

Every platform action is scriptable and discoverable from the command line.

Documentation as spec

Docs describe the one correct implementation — not a menu of options.

05

Built for Humans

Teams ship without integration variance

Humans and AI agents are first-class authors. The platform is designed so author identity does not determine code quality or structure.

Junior developers should not produce structurally different code from seniors. AI agents should not guess project conventions. Conflux encodes conventions into scaffolding, SDKs, CLI commands, and lint rules so the author's experience level changes speed — not outcome.

Junior = senior output

Scaffolding and SDK enforce the canonical path. Experience affects velocity, not structure.

No reinventing integrations

Auth, sync, and communications work the same way in every Conflux project.

Offline-first

Build applications that work without connectivity and sync when online.

Review business logic

Code review focuses on what the app does — not how integrations were wired.

06

Developer Experience

From scaffold to production

Public npm packages are live. Day-0: create → link → push against staging or your self-hosted API.

01

npx create-conflux@latest my-app

Scaffold from npm (no monorepo clone)

02

npx conflux link && npx conflux push

Auth + project + publish schema/handlers

03

CONFLUX_API_URL=https://dsync.vipani.co npm run dev

Run Vite shell against staging alpha

07

Open Source

Inspect, fork, deploy anywhere

Conflux Stack is open source under the MIT license. The platform architecture, design system, and application shell are available today. Platform services ship as integrated modules — never as proprietary add-ons.

View repository

08

Community

Build with us

Conflux Stack is shaped in the open. Follow development, contribute platform modules, or discuss architecture with the team.

CommunityDiscordRoadmap

Start with the documentation

Read the platform overview, explore the layer architecture, and follow the getting-started guides.

Get startedRead docs