The platform
Underneath the app that answers on your WhatsApp runs a built multi-tenant platform — 39 engines across 10 layers, governed and verifiable by evidence. What the home page demonstrates, engineering delivers. This is the page that pops the hood: the substance, with the honest status of each part.
Stage honesty
Every claim on this page carries a badge. That’s how you separate fact from bet without relying on our goodwill — proof, not promise.
Where we honestly stand right now: Next chapter: dogfooding — Fluxomind running its own sales operation inside the product, the living proof that the agent operates and evolves.
AI-first
In traditional software, code calls the LLM when it needs to. Here it’s the inverse: an orchestrator receives the intent, consults memory and knowledge, plans and invokes tools — all governed by policy and visible as a state graph, auditable step by step.
Partial — multi-worker journey in hardeningRouting by cost/quality profile, automatic fallback across providers and cost measured per call.
The agent composes existing primitives — it does not generate loose code. Execution is visible and reproducible.
Extends the tenant’s model via governed tools (create-only), with the system’s base tables locked — dogfooding, not self-modification.
Architecture
All organized into 10 layers, verifiable in src/engine/. Every engine is an isolated module with strict boundaries — an improper import between internals is blocked by the boundary verifier, which runs on demand and in the deploy pipeline. Evolution by layer, no breaking changes.
Machine-verified, in the deploy pipelineagentStudio · model · prompt · memory · ragtool · mcpapp · appStore · dataView · speechworkflow · codesecurity · policy · quota · auditTrailatlas · data · metadata · cache · queue · filemonitoringdeployment · operations · validationapi · pluginfeedback · fineTune · eval · evolutionFlywheel + Atlas
The platform doesn’t deliver value once — it spins. Two coupled loops over a single semantic brain: intent becomes an app, the app generates activity, the activity returns the next action — and each turn starts from a higher point.
You describe the intent; the platform creates object, fields and screens — with no engineering cycle in the way.
Operating generates real data; the platform reads the activity and suggests the next step — more precise than the last. The full turn is what dogfooding proves.
Under constructionClassifies the business entities (embedding + LLM, aligned to Schema.org) — no manual ontology project.
Under constructionThe thesis: the more you use it, the more Atlas knows — and the cheaper it gets to deliver the next thing. That’s what separates a flywheel product from a tool. The full turn is what dogfooding will prove.
Performance & scale
The scale capabilities are in the architecture. Production numbers arrive with the pilots.
Partial — design capabilityPrometheus metrics, SLOs per tier, anomaly detection (z-score/IQR) and cost trace per execution.
monitoringEngineDistributed queue with retries, backoff and DLQ; layered cache; connection pools and slow-query detection.
queueEngine · cacheEngine · dataEngineMulti-region DR, auto-scaling and self-healing (designed), tier-based backup with RPO/RTO and distributed tracing (OpenTelemetry).
operationsEngineQuality & correctness
The principle is trust earned by evidence: the platform verifies itself by code — suites that prove isolation, integrity and contracts, not a checklist.
ImplementedIsolation (cross-tenant probes + RLS via pgTAP), integrity, contracts, resilience, compliance and evolvability. Boundaries, tests and the eval gate run on demand and in the deploy pipeline; the isolation suite in a dedicated workflow.
validationEngineLLM-as-Judge and property-based tests block regressions before a flow is promoted.
evalEngineAPI contracts (OpenAPI) and event contracts (AsyncAPI) verified; tests co-located with the code.
validationEngine · co-located testsGovernance
Limits in the architecture, not in each app’s code: declarative policy the runtime enforces across the platform, with a person in the loop when it matters.
Partial — core implemented; self-service on the roadmapVersioned guardrails (checksum), evaluated with cache and explain; human approval (human-in-the-loop) on sensitive actions.
policyEngineRate limiting, usage tracking and enforcement per tenant; atomic reservation and approved overrides.
quotaEngineGDPR/LGPD consent lifecycle and an immutable hash-chain audit trail (see Security).
securityEngine · auditTrailEngineSecurity
Strong multi-tenancy, encryption and masking — from day one, with nothing for the customer to configure. Enterprise-grade capability, delivered to people who aren’t technical.
ImplementedBring your own KMS key (AWS/GCP/Azure). Crypto-shredding: revoke the key and the data becomes unreadable immediately — independently of the platform.
securityEngine · spec-byokDedicated schema per customer + RLS as backstop. The tenantId never comes from the payload — it derives from the request context.
securityEngine · dataEngineSensitive data masked (4 strategies) before reaching the LLM; guards against prompt-injection and jailbreak.
securityEngine · spec-content-safetyDual token + RBAC; SHA-256 append-only trail — tampering is cryptographically detectable and verifiable per tenant.
securityEngine · auditTrailEngine · spec-hash-chainDistribution & connections
The platform connects to what you already use and operates through the channel where the business already lives. The App Store engine exists in the Experience layer — the motor ready for the catalog of self-operating apps the vision describes.
Operation over WhatsApp at the platform level — a governed channel, not a personal number tied to one app. Voice and text on the same trail.
Under constructionEmail, API, MCP and plugins — the app absorbs spreadsheets and systems and hands back a single, governed operation, without dropping your way of working.
Under constructionWhoever masters a problem packages the method; your company installs it and adopts it already running. The engine exists; the public catalog is the vision.
VisionMaturity & compliance
The platform has automated scanners for SOC2 controls (CC6/CC7/CC8) and GDPR (Art. 17/20/30/32) — verification by code, not a manual checklist. Today they run on demand; scheduled continuous execution is on the roadmap.
| Pillar | What we already deliver | Status | Next step |
|---|---|---|---|
| Security | BYOK, PII masking, RBAC, hash-chain audit | Implemented | Broad fail-closed + external pen-test |
| Quality | Quality invariants, LLM-as-Judge, contracts | Implemented | Load coverage at scale |
| AI-first | Governed multi-agent orchestration; multi-provider with fallback and measured cost | Partial | Multi-worker journey in hardening; more autonomy patterns |
| Governance | Policies + HITL, quotas/entitlements, consent | Partial | Billing/payment + self-service governance panel |
| Performance | SLOs, cost trace, multi-region DR, self-healing (design) | Partial | Production scale numbers (post-pilot) |
| Compliance | Automated SOC2/GDPR scanners (on demand) | Partial | Continuous execution + SOC2 Type II certification (external audit) |
The next step
The platform is in private beta. Join the list to operate with the team right alongside you — and, if you’re technical, ask for the data room (arch docs, specs, evidence) and an architecture session.