Architecture
Architecture Overview
Natively is built around two tightly integrated but clearly separated layers:
App Generation Layer (Vibecoding App) – where ideas become software.
Orchestration Layer (Conductor) – where software becomes a reliable, policy-compliant running system.
The App Generation Layer is the user-facing product. It is a conversational, intent-driven environment that turns natural language into full application artifacts: frontend, backend, data models, integrations, and configuration.
The Orchestration Layer is the execution and control plane. It takes a generated application and runs it according to declared goals, constraints, and policies—handling deployment, scaling, governance, reliability, and cost control.
This separation ensures fast creative iteration during building, and strict determinism during execution.
App Generation Layer
The App Generation Layer is the creation environment where users turn ideas into runnable software through conversation.
Core properties:
Natural language to code: users describe goals and features, not frameworks or infrastructure.
Conversational iteration: changes happen through dialogue (e.g. “add auth”, “connect a database”, “change the UI”).
Live preview & sandboxing: generated apps run instantly in an isolated environment with real-time visual feedback.
Component & integration aware: apps are assembled from validated components and managed integrations.
Skill-adaptive: non-technical users work purely in objectives, while developers can inspect and modify generated code when needed.
The output of this layer is a self-contained, runnable application artifact (code + configuration).
Creation, iteration, and packaging all happen here. No orchestration logic is involved until the user explicitly requests execution.
Execution Intent & Policy Layer
Intent exists in two forms in Natively:
Creative intent during building, which is conversational, fuzzy, and iterative (handled in the App Generation Layer).
Execution intent during deployment, which is structured, formal, and policy-bound (handled by the Orchestration Layer).
When a user says “Deploy this,” the system converts the generated application into a structured execution intent.
This execution intent defines:
service type (web app, job, agent, API),
availability and performance targets,
cost and resource limits,
compliance and data-sovereignty constraints.
Only this execution intent is treated as deterministic, versioned, auditable, and policy-governed.
Orchestration Layer (Conductor)
Conductor is not a creation tool. It is the execution brain of Natively.
It takes a completed application artifact from the App Generation Layer and turns it into a managed, running system.
Users define outcomes and constraints; Conductor decides how to achieve them across cloud, on-prem, and edge environments.
This layer is responsible only for:
deployment,
scaling,
resilience,
governance,
cost control.
Internally, it is structured into:
Intent & Policy Layer – interprets execution requests, SLAs, budgets, and compliance rules.
Planning & Optimization Layer – selects optimal infrastructure and continuously re-plans.
Execution & Federation Layer – deploys workloads across cloud, on-prem, and edge via adapters.
Observability & Feedback Layer – monitors performance, cost, and reliability and feeds data back into planning.
Creation vs Execution
Creation and execution are separate phases.
Applications are created, iterated, and validated in the App Generation Layer.
Only after user approval does execution begin, when the Orchestration Layer takes over to run the application as a managed system.
Generation never happens inside orchestration. Orchestration never edits or designs applications.
Marketplace, Templates, and Vibe to Earn
Templates, components, and marketplace assets belong to the App Generation Layer.
They are used during application creation and iteration, not during orchestration.
Builders create reusable components, flows, and templates that appear in the vibecoding environment and can be combined through conversation.
Vibe to Earn operates entirely at the creation layer:
Builders submit templates and components.
Users adopt them while building apps.
Rewards and marketplace fees are tied to usage during creation.
Orchestration only operates on the final application artifact, regardless of whether it was built from scratch or from marketplace components.
No-Code by Default, Code When Needed
Natively is no-code by default, but code-visible when needed.
Non-technical users work entirely through natural language.
Developers can inspect, constrain, or modify generated code when required.
This allows teams to move fast without blocking advanced control.
Last updated