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.
One platform · native modules
Offline-first
Your app
Auth
Sync
Database
Queue
Comms
AI
SDK
UI
31 modules · one SDK · one path each
Full registry01
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 appAI 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 fieldDeveloper 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 jobsCLI
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
02
Data Layer
Schema, database, sync, storage, and search — offline-first by design.
5 modules
5 live
03
Runtime Layer
Realtime, queues, functions, and scheduled jobs.
4 modules
4 live
04
Communication Layer
Outbound channels and in-app notification center.
2 modules
1 live
05
Intelligence Layer
Analytics, AI, and autonomous agents.
3 modules
1 live
06
Automation Layer
Workflows and business rules.
2 modules
07
Integration Layer
Webhooks, public API, and SDK.
3 modules
3 live
08
Experience Layer
UI components and extensibility.
2 modules
1 live
09
Platform Operations
Tenant management, observability, and lifecycle operations.
6 modules
3 live
Every capability has a planned status, description, and canonical integration path in the full platform registry.
Full capability map04
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.
Start with the documentation
Read the platform overview, explore the layer architecture, and follow the getting-started guides.