Introducing /apps: Ship web applications from a single prompt

Today we're launching /apps — the primitive that lets your AI agent create, build, deploy, and manage real web applications. Naïve-managed Next.js projects with an optional managed database, dedicated engineer agents, preview deployments, production promotion, custom domains, and environment variables. One prompt to the CEO and your agent ships a live website.

The problem: agents can write code but can't ship it

Every code-generation model can produce a React component. None of them can ship it. The gap between "here's some code" and "here's a live URL" is enormous: you need a hosting platform, a deploy pipeline, environment variables, database provisioning, DNS configuration, and someone to promote preview to production.

The status quo is fragmented:

• Generic hosting platforms — built for human developers. Push to git, wait for CI, click buttons in dashboards. No API for "create project, deploy code, connect domain" in one flow.
• v0 / Bolt / Lovable — generate code in a sandbox, but the sandbox is a walled garden. Extracting it to production infrastructure is manual work.
• DIY pipelines — build a deploy script, manage runtime tokens, provision managed database projects, configure DNS. Weeks of integration work.

The gap is this: there's no primitive where "ship a web app" is a CLI command your agent can call after writing code. Until now.

How /apps works

The lifecycle is five steps:

1. Create — naive apps create --name "My Product" --type fullstack provisions a managed runtime project, managed database project (for fullstack), and a dedicated engineer agent profile.
2. Build — the engineer agent writes code in its workspace, guided by kanban task descriptions from the CEO or your direct instructions.
3. Deploy — naive apps deploy <app-id> pushes the workspace to managed runtime as a preview deployment with a unique URL.
4. Publish — naive apps publish <app-id> --deployment <id> promotes a preview to production with zero downtime.
5. Iterate — deploy again, manage secrets, connect domains, query the database — the full lifecycle is API-native.

This is the Company → Employee → Primitive model: the Company owns the infrastructure, the Employee (engineer agent) builds and deploys, and /apps is the primitive that binds code to live URLs.

CLI: create to production in four commands

# Create a fullstack app
naive apps create --name "StudyAI" --type fullstack --description "AI study assistant"
 
# Engineer builds code via tasks...
# Then deploy a preview
naive apps deploy <app-id>
# → Preview URL: https://naive-studyai-abc123-preview.usenaive.app
 
# Promote to production
naive apps publish <app-id> --deployment <deployment-id>
# → Live at: https://naive-studyai-abc123.usenaive.app
 
# Connect a custom domain
naive apps domains add <app-id> studyai.com
naive apps domains verify-dns <app-id> <domain-id>

Every command returns structured JSON with the deployment URL, status, and next steps — agents know exactly what to do next.

API: full lifecycle management

// Create an app
const res = await fetch("https://api.usenaive.ai/v1/apps", {
  method: "POST",
  headers: {
    "Authorization": `Bearer ${process.env.NAIVE_API_KEY}`,
    "Content-Type": "application/json",
  },
  body: JSON.stringify({
    name: "StudyAI",
    type: "fullstack",
    description: "AI study assistant",
  }),
});
const app = await res.json();
// app.id, app.runtime.production_domain, app.status
 
// Deploy preview
const deploy = await fetch(`https://api.usenaive.ai/v1/apps/${app.id}/deploy`, {
  method: "POST",
  headers: { "Authorization": `Bearer ${process.env.NAIVE_API_KEY}` },
});
const { id, url } = await deploy.json();
 
// Promote to production
await fetch(`https://api.usenaive.ai/v1/apps/${app.id}/publish`, {
  method: "POST",
  headers: {
    "Authorization": `Bearer ${process.env.NAIVE_API_KEY}`,
    "Content-Type": "application/json",
  },
  body: JSON.stringify({ deploymentId: id }),
});

The API covers the full app lifecycle — creation, deployment, secrets, domains, and database access. See the full API reference for the current endpoint list.

Environment variables synced to the managed runtime

Manage secrets per-target so preview and production environments stay isolated:

# Preview-only API key for testing
naive apps secrets set <app-id> API_KEY sk_test_... --target preview
 
# Production key for live traffic
naive apps secrets set <app-id> API_KEY sk_live_... --target production
 
# Reveal when needed
naive apps secrets reveal <app-id> API_KEY --target production

For fullstack apps, NEXT_PUBLIC_SUPABASE_URL and NEXT_PUBLIC_SUPABASE_ANON_KEY are automatically provisioned — you never configure database connection details manually.

Database access for fullstack apps

Fullstack apps include a full managed database PostgreSQL database. Query it directly from the CLI:

# List tables
naive apps db tables <app-id>
 
# Run queries
naive apps db query <app-id> "SELECT count(*) FROM users WHERE created_at > now() - interval '7 days'"

Use the managed database client in your app code for real-time subscriptions, auth, row-level security, and storage. The engineer agent has full access to schema design and migrations.

Composes with /orchestration

When the CEO creates a plan that includes web applications, the integration is automatic:

1. CEO calls naive apps create to provision infrastructure
2. CEO hires an engineer agent assigned to the app
3. CEO creates tasks with deployment instructions auto-injected — the engineer knows exactly which app to deploy and how
4. Workers build code and run naive apps deploy + naive apps publish autonomously
5. After deploy, the task is marked complete with the live URL as metadata

You don't write deploy scripts. You don't configure CI/CD. The orchestration layer handles the full create-build-deploy-publish lifecycle.

What you can build with /apps

Launch landing pages from a single prompt — Tell the CEO "Build a landing page for our SaaS product" and get a live managed runtime deployment with custom domain, responsive design, and analytics — no code pushed manually.

Ship fullstack SaaS products autonomously — Provision a Next.js + managed database app, let the engineer agent build auth, dashboards, and API routes, and deploy to production — all via kanban tasks.

Run a portfolio of micro-sites — Each client or project gets its own app with isolated secrets, domains, and database. Manage the fleet via naive apps list and iterate independently.

Prototype and iterate at agent speed — Deploy previews, review at unique URLs, provide feedback via task comments, and redeploy. The cycle time between "I want a change" and "it's live" is minutes, not hours.

Compose with every other primitive — Apps can send email, connect social accounts, process payments, run SEO, and use search. The engineer agent has access to the full primitive library.

Get started

Drop this starter prompt into any coding agent to wire up Naïve:

Read https://usenaive.ai/skill.md and use it to set up Naïve in my project.

• Read the docs: usenaive.ai/docs/getting-started/apps
• CLI reference: usenaive.ai/docs/cli/apps
• API reference: usenaive.ai/docs/api-reference/apps/overview
• Quickstart: usenaive.ai/docs/getting-started/quickstart
• Background: Naïve's managed runtime and managed database power /apps end-to-end.
• Join the community on Discord