NEXUS AI

The AI creation platform. Describe an app, watch it build, preview and share it, then deploy the full stack to production. Your AI agent runs the rest.

What is NEXUS AI?

NEXUS AI is an agentic AI app builder and deployment platform. You describe what you want in plain words, and NEXUS AI builds it, verifies it, shows you a live preview you can share or remix, and deploys it when you're ready.

Every deploy ships the whole stack, already connected: app code, Postgres, MySQL, Mongo or Redis, S3-compatible buckets, persistent volumes, background workers, and encrypted backups, plus Stripe payments when your app needs them. Run it on NEXUS AI managed infrastructure or in your own AWS, Google Cloud, or Azure account.

It also includes standalone managed databases, an AI Gateway for routing model traffic, and 74 MCP tools, so Claude, Cursor, Codex, or any MCP-compatible agent can build, deploy, scale, back up, restore, query the database, and roll back without leaving the chat or IDE.

The problem it solves. AI tools like Claude Code, Cursor, v0, Bolt, Lovable, and Replit can generate working application code in minutes. Getting that code into production still requires the rest of a real stack: a database, a queue, storage, secrets, scaling, health checks, backups, rollbacks. NEXUS AI is the deploy layer that closes that gap and exposes every operation to the agent that wrote the code.

In one sentence. Describe what you want to build, preview it live, ship to a public HTTPS URL with Postgres + Redis + S3 in 5 minutes, then let your AI agent operate the stack on your behalf.

How It Works

Four equivalent ways to get the same app running. Pick one or use all of them.

PROMPT
  Tell Claude in chat: "Deploy this repo with Postgres, Redis,
  and a bucket called user-uploads."
  → The agent calls nexusai_deploy_source + nexusai_bucket_create
    + nexusai_bucket_attach + nexusai_deploy_redeploy.
  → Live URL in ~5 minutes.

REPO
  nexus deploy source \
    --repo https://github.com/you/my-app.git \
    --framework python \
    --services postgresql,redis \
    --bucket user-uploads --wait

BUILDER
  Describe the app at https://nexusai.run/builder. Watch it render in a
  live preview, edit the code or click an element to change it, then
  press Deploy. Same pipeline as the CLI.

DASHBOARD
  Click through the same operations at https://nexusai.run/app.
  Same engine, same result.

After deploy, the agent (or you) operates the running stack: stream logs, scale replicas, snapshot the database, restore from backup, run a sandboxed SQL query, apply an AI-proposed schema fix, roll back to a previous release. Every action is an MCP tool, a CLI command, and a dashboard button.

Core Features

AI App Builder

Chat-driven app builder with a live, sandboxed preview. Generates React apps and full-stack Next.js + Prisma apps, including an auto-provisioned managed Postgres database and built-in email/password auth. The preview self-heals (up to two automatic AI fix attempts on build errors), and a "Fix with AI" action repairs a failed deploy and redeploys against the same database. Also included:

• Click-to-edit element selection and image attachments the AI can see (mockups, bug screenshots)
• A restorable checkpoint on every turn, plus push to a new or existing GitHub repository
• Import an existing GitHub repo: Next.js and Vite get a hot-reload dev container, and Django, Rails, Laravel, FastAPI and other frameworks get a real running preview
• MCP handoff: nexusai_builder_push sends files generated in Claude, Cursor, or ChatGPT into the builder for a free instant preview, and nexusai_builder_pull reads edits back
• Model picker with Claude (Fable 5.1, Opus 5), OpenAI (GPT-6 Astra), Google (Gemini 3.8 Flash, the managed default on the Free plan), and xAI Grok, plus bring-your-own-key AI providers

Full-stack deploys in one command

Postgres, MySQL, Mongo, Redis, S3-compatible buckets, persistent volumes, background workers, and your app code. Wired together by one nexus deploy and live at a public HTTPS URL in 5 minutes. Framework detection covers FastAPI, Flask, Django, Express, Next.js, Rails, Laravel, Symfony, PHP, Ruby, Go, Java, and any container.

Operated by your AI agent

74 MCP tools cover the full lifecycle. Connect the NEXUS AI MCP server (https://mcp.nexusai.run/mcp) to Claude Desktop, Claude Code, Cursor, Codex, or any MCP client. The same agent that generated the code can deploy, scale, back up, restore, query the database, and roll back. Listed on the official MCP Registry at io.github.nexusrun/nexus-ai.

Persistent storage with real IAM

Org-scoped volumes that survive container restarts, redeploys, and host reboots. Multi-attach S3-compatible buckets backed by MinIO, each with its own scoped IAM service account (not platform-wide root credentials). Per-bucket credential rotation, signed download URLs (30 seconds to 1 hour TTL), streaming uploads.

Standalone managed databases

Databases are their own resource, not part of an app. Create PostgreSQL or Redis on NEXUS AI (--local), or PostgreSQL and MySQL on AWS RDS, Google Cloud SQL, or Azure Database. Set your own database name, username, and password, attach to any deployment (env vars are injected on the next deploy, REDIS_URL for Redis), detach without losing data, and snapshot or restore into a new database. Private cloud databases are reached through an in-VPC/VNet proxy, so they are never exposed publicly. Run SQL from the CLI (nexus managed-db query shop "SELECT ..."), the dashboard, or MCP. Redeploying or deleting an app leaves the database untouched.

AI Gateway

An OpenAI- and Anthropic-compatible gateway (/v1, /v1/messages) with failover and routing, virtual model aliases, caching, budgets and rate limits, usage and cost tracking, guardrails, audit logs, and an MCP gateway that aggregates servers behind one endpoint. Provider keys stay in the gateway. Supports Anthropic, OpenAI, Google Gemini, xAI Grok, OpenRouter, and any OpenAI-compatible endpoint. Self-hostable on NEXUS AI. nexusai.run/ai-gateway

Database intelligence layer

Connect external Postgres, MySQL, or Mongo databases. Inspect schemas (cached for 5 minutes). Preview queries with EXPLAIN + safety analysis. Execute sandboxed SELECT statements with statement timeouts and row caps. Apply AI-proposed DDL fixes generated from runtime error logs (with review and audit).

Encrypted backups, signed downloads

Scheduled or on-demand backups for Postgres (pg_dump), MySQL (mysqldump), Mongo (mongodump), and Redis (BGSAVE). Encrypted at rest. Scheduled backups default to 7-day retention and prune automatically (configurable, never below 7 days). Download via short-lived signed URLs (TTL 30s to 1h) or restore directly. Cross-deployment restore (seed staging from production) supported.

Production-safe lifecycle

Soft stop preserves containers, networks, volumes, and the port reservation so the next start brings everything back. Boot reconciliation restarts deployments the host reboot did not bring back. Versioned rollback in seconds. Replica count preserved across restart.

Three deploy paths, one engine

Dashboard, CLI (nexus deploy), or MCP tool call from your agent. Same engine, same result. Switch between them in the same project without anything getting out of sync.

Multi-cloud single-container deploys

Full-stack deploys run on the NEXUS AI managed Container platform with org-level isolation. Single-container apps can also target AWS App Runner, Google Cloud Run, or Azure Container Apps from the same dashboard, CLI, or MCP call.

Real-time observability

Streaming build and runtime logs over WebSocket. Health checks with configurable endpoints. Tail logs directly from your agent (nexusai_deploy_logs) to triage failures without leaving chat.

Encrypted secrets vault

AES-256-GCM encryption. Injected at container start, never written to images, never returned over the API, never appear in logs. Scoped per organization and environment with full audit trail on every read, write, and deletion.

Role-based access control and tenant isolation

Org-level roles (Owner, Admin, Developer). Per-org isolated runtime, networks, volumes, and S3 buckets. SAML / OIDC SSO available on Enterprise. Independently scoped and revocable API tokens with fine-grained OAuth scopes (deployments:read, db:admin, managed_db:manage, volumes:manage, buckets:manage, etc.) plus four legacy broad scopes preserved for backward compatibility.

Support and custom domains

Custom domains on Starter and above. Support by plan: community on Free, email and tickets on Starter, plus phone on Pro, dedicated SLA on Enterprise. Agents can open and reply to support tickets over MCP. See the customer support page.

HIPAA-aligned infrastructure

Tenant isolation, encrypted secrets, encrypted backups, scoped per-bucket IAM, full audit logs, customer-owned cloud deployments for Enterprise, BAA available for Healthcare Pro and Enterprise.

Supported deploy targets

Full-stack deploys (app + databases + storage + workers + backups) run on the NEXUS AI managed Container platform. The cloud-provider targets are for single-container apps that do not need the full managed stack.

Where NEXUS AI is listed

Install in any MCP client by searching "NEXUS AI" in the client's MCP marketplace, or via the registry URL above.

Pricing

Free at $0

• 1 active deployment on NEXUS AI managed infrastructure
• 5 AI requests per day, 3 secrets, public HTTPS endpoint
• Community support
• For testing and development. See the Free plan usage policy

Starter at $29/month

• Application Generation Engine, 10 AI requests per day
• NEXUS AI managed Container platform (shared runtime)
• 2 active deployments, Google Cloud Run target
• Public HTTPS endpoint and custom domain
• Email support and support tickets
• Standalone databases

Pro at $149/month

• Everything in Starter, 30 AI requests per day
• Multi-cloud deploys (AWS App Runner, Google Cloud Run, Azure Container Apps)
• 5 active deployments, up to 10 concurrent containers
• Versioned deployments and one-click rollback
• Real-time build and runtime observability
• AES-256-GCM secrets vault
• Team access with RBAC (up to 10 members)
• Phone support on top of email and tickets

Enterprise (custom)

• Everything in Pro
• Deploy into customer-owned AWS, Google Cloud, or Azure accounts
• Private build and runtime isolation
• Unlimited deployments and versions
• Advanced audit logs (HIPAA / SOC-ready)
• SSO (SAML / OIDC), IP allowlisting, and network controls
• Dedicated support and SLA
• Enterprise On-Prem adds air-gapped and on-premises deployment

View full pricing · Healthcare pricing

NEXUS AI vs alternatives

Who Uses NEXUS AI

AI app builders

Build in the NEXUS AI Builder, or ship apps generated by Claude Code, Cursor, v0, Bolt, Lovable, or Replit, with a real database, real storage, and a real public URL in 5 minutes. Let the same agent that wrote the code operate the deploy.

Teams building agent products

Expose your platform actions as MCP tools so end-user agents can deploy, operate, and scale on your customers' behalf.

SaaS founders

Launch new ideas without spending a week on infrastructure. Stand up new apps with Postgres, Redis, and storage from one command.

Platform and DevOps teams

Give every internal team a self-service deploy path with audit logs, RBAC, and rollback baked in. No tickets, no glue scripts.

Role-specific guides

Dedicated pages for developers, founders, sales, product managers, small business, entrepreneurs, and vibe coders.

Regulated industries (Healthcare and Fintech)

Deploy into customer-owned cloud infrastructure with HIPAA-aligned controls, full audit trails, tenant isolation, and BAA support.

Quick Start

1. Install the CLI

# macOS
curl -fsSL https://nexusai.run/install-mac.sh | bash

# Linux
curl -fsSL https://nexusai.run/install.sh | bash

Authenticate:

nexus auth login
nexus auth status

2. Deploy a full-stack app from a Git repo

nexus deploy source \
  --repo https://github.com/you/my-app.git \
  --name my-app \
  --provider docker \
  --framework python \
  --services postgresql,redis \
  --start-command "uvicorn app:app --host 0.0.0.0 --port 8000" \
  --wait

NEXUS AI builds the container, provisions Postgres + Redis with persistent volumes, opens a public HTTPS URL through Traefik, and starts streaming logs.

3. Attach a bucket for uploads

nexus bucket create user-uploads
nexus bucket attach <bucket-id> <deployment-id>
nexus deploy redeploy <deployment-id> --wait

Your app receives S3_ENDPOINT, S3_BUCKET, S3_ACCESS_KEY, S3_SECRET_KEY as environment variables. Use any S3 SDK against the scoped per-bucket service account.

4. Create a standalone database and query it

nexus managed-db create shop --local --engine postgres
nexus managed-db attach shop --deployment my-app
nexus deploy redeploy my-app --wait

nexus managed-db query shop "SELECT count(*) FROM orders"
nexus managed-db connection shop --url-only

Always quote the SQL. Queries run one statement at a time, and CREATE DATABASE, DROP DATABASE, and GRANT are blocked. Full CLI reference: wiki/CLI.md.

5. Operate from your agent

Connect the NEXUS AI MCP server to Claude Desktop, Claude Code, Cursor, or Codex (https://mcp.nexusai.run/mcp). The agent can then run commands like:

"Take a Postgres backup of my-app, run the migration, and roll back if anything fails."

The agent calls nexusai_db_services_list, nexusai_db_backup, then conditionally nexusai_db_restore and nexusai_deploy_rollback, all without you opening a terminal.

Full documentation · MCP Server Reference

API and MCP Integration

NEXUS AI exposes a REST API and a full MCP server with 74 tools across 11 categories:

OAuth scopes. 4 legacy broad scopes (deployments:{read,logs,create,delete}) kept for backward compatibility, plus fine-grained scopes (secrets:{read,manage,delete}, domains:{read,manage,delete}, db:{read,query,admin,source:delete}, volumes:{read,manage,delete}, buckets:{read,manage,delete}, managed_db:{read,manage,delete}, support:{read,write}). Old tokens continue to satisfy fine-grained checks via SCOPE_SUPERSETS.

Connect from Claude Desktop

Add to ~/Library/Application Support/Claude/claude_desktop_config.json (macOS) or %APPDATA%\Claude\claude_desktop_config.json (Windows):

{
  "mcpServers": {
    "nexus-ai": {
      "type": "http",
      "url": "https://mcp.nexusai.run/mcp"
    }
  }
}

Connect from Claude Code

claude mcp add --transport http nexus-ai https://mcp.nexusai.run/mcp

Connect from Cursor

Cursor Settings, MCP, Add server, with the same URL.

The MCP server authenticates with OAuth 2.0 + PKCE. Claude Code, Claude Desktop, and Cursor run the sign-in in a browser on first connect. For headless clients, mint an OAuth token with the PKCE flow (nexusai.run/docs#mcp-oauth-flow) and send it as Authorization: Bearer <token>. Full MCP reference at nexusai.run/docs#mcp-overview.

API Documentation

Tools

The NEXUS AI MCP server (https://mcp.nexusai.run/mcp, streamable HTTP, OAuth or Bearer token) exposes 74 tools.

Identity and discovery

• nexusai_whoami: Returns the authenticated NEXUS AI user and tenant context.
• nexusai_projects_list: Lists projects available in the current tenant.
• nexusai_providers_list: Lists deployment providers allowed for the tenant plan.
• nexusai_usage_stats: Returns usage statistics, quotas, and deployment counts for the organization.

AI App Builder

• nexusai_builder_push: Push a generated app file set into the project's AI Builder session.
• nexusai_builder_pull: Read the current file set of the project's AI Builder session (latest snapshot, including any edits made in the builder UI) so you can continue iterating in chat.

Deployments

• nexusai_deploy_list: Lists deployments available to the authenticated tenant.
• nexusai_deploy_status: Returns status details for a deployment.
• nexusai_deploy_logs: Returns recent log lines for a deployment.
• nexusai_deploy_create: Create a deployment from a container image on NEXUS AI managed infrastructure or a connected AWS, Google Cloud or Azure account.
• nexusai_deploy_openclaw: Deploy an OpenClaw gateway service (alpine/openclaw:latest) on port 18789.
• nexusai_deploy_flixty: Deploy Flixty.
• nexusai_deploy_source: Deploy from a Git repository, optionally a sub-folder (rootDir), to NEXUS AI managed infrastructure or a connected AWS, Google Cloud or Azure account.
• nexusai_deploy_redeploy: Rebuild a deployment IN PLACE by default: same deployment id and URL, with attached managed databases, volumes, secrets and env vars preserved (override env via overrides.envVars).
• nexusai_deploy_rollback: Rollback by redeploying a previous deployment revision in the same project.
• nexusai_deploy_stop: Stop a running deployment without deleting it.
• nexusai_deploy_start: Start a stopped deployment.
• nexusai_deploy_delete: Permanently delete a deployment and free its resources.
• nexusai_deploy_scale: Scale a running deployment to the specified number of replicas (1-10).
• nexusai_deploy_auto_destroy: Set, extend, reduce, or disable the auto-destroy schedule for a deployment without restarting it.
• nexusai_deploy_health: Returns health check status and recent health logs for a deployment.

Secrets

• nexusai_secrets_list: Lists all secrets for the organization (values are hidden).
• nexusai_secrets_create: Create a new secret for the organization.
• nexusai_secrets_update: Update an existing secret.
• nexusai_secrets_delete: Delete a secret from the organization.

Custom domains

• nexusai_domains_add: Add a custom domain to a deployment.
• nexusai_domains_list: List custom domains attached to a deployment.
• nexusai_domains_verify: Trigger DNS verification for a custom domain.
• nexusai_domains_remove: Remove a custom domain from a deployment.

Managed databases

• nexusai_managed_db_list: List org-scoped managed cloud databases (AWS RDS instances).
• nexusai_managed_db_create: Create a standalone database, independent of any deployment, then attach it to apps.
• nexusai_managed_db_delete: Permanently delete a managed database instance.
• nexusai_managed_db_connection: Reveal connection details, including the password, for a NEXUS_DOCKER (local) database.
• nexusai_managed_db_attach: Inject connection env vars (DATABASE_URL/HOST/PORT/USER/PASSWORD/NAME) into a deployment.
• nexusai_managed_db_detach: Stop injecting the database connection env vars on next deploy.
• nexusai_managed_db_snapshot_create: Take a point-in-time snapshot backup of a managed database (AWS RDS snapshot).
• nexusai_managed_db_snapshot_list: List snapshot backups for a managed database.
• nexusai_managed_db_query: Run a read-only SELECT against a managed database (rejects writes/DDL).
• nexusai_managed_db_execute: Run a write or DDL statement (INSERT/UPDATE/DELETE/CREATE/ALTER/...) against a managed database.
• nexusai_managed_db_restore: Restore a snapshot into a NEW managed database instance (non-destructive).

Database backups

• nexusai_db_services_list: List all database services (postgres, mysql, redis, mongo, etc.) provisioned alongside deployments.
• nexusai_db_backup: Create a backup of a database service in a Docker deployment.
• nexusai_db_backup_list: List available backups for a database service.
• nexusai_db_backup_download: Generate a short-lived signed download URL for a backup file.
• nexusai_db_restore: Restore a database service from a previously created backup.
• nexusai_db_restore_to: Restore a database backup into a different deployment service in the same org.
• nexusai_db_backup_schedule: Enable or disable daily automated backups for a database service.

Database intelligence (external sources)

• nexusai_db_source_list: List all external DB sources for the organization.
• nexusai_db_source_connect: Create & test a new external DB connection.
• nexusai_db_source_delete: Remove an external DB source.
• nexusai_db_inspect_schema: Get normalized schema graph for a DB source.
• nexusai_db_query_preview: Dry-run a SQL query (EXPLAIN + safety analysis).
• nexusai_db_query_execute: Execute confirmed SQL against an external DB source.
• nexusai_db_propose_fix: Analyze deployment log errors and propose DDL fix.
• nexusai_db_apply_fix: Apply a DDL fix previously returned by nexusai_db_propose_fix.

Volumes

• nexusai_volume_list: List org-scoped persistent storage volumes (filesystem mounts).
• nexusai_volume_create: Create a new org-scoped persistent volume.
• nexusai_volume_delete: Delete a volume.
• nexusai_volume_attach: Attach a volume to a deployment at a mount path.
• nexusai_volume_detach: Detach the volume from its current deployment.

Buckets

• nexusai_bucket_list: List org-scoped object-storage buckets (S3-compatible MinIO buckets).
• nexusai_bucket_create: Create a new org-scoped bucket on the shared MinIO instance.
• nexusai_bucket_delete: Delete a bucket.
• nexusai_bucket_attach: Expose the bucket to a deployment via S3_* env vars (S3_ENDPOINT, S3_BUCKET, S3_ACCESS_KEY, S3_SECRET_KEY, S3_REGION).
• nexusai_bucket_detach: Remove the bucket from a deployment.
• nexusai_bucket_rotate_credentials: Generate fresh per-bucket MinIO service-account credentials, replacing the previous ones.
• nexusai_bucket_files_list: List objects in a bucket, optionally filtered by key prefix.
• nexusai_bucket_file_upload: Upload a file to a bucket from base64-encoded content.
• nexusai_bucket_file_download: Issue a short-lived signed URL to download a file from a bucket without an API token.
• nexusai_bucket_file_delete: Delete a single file from a bucket.

Support tickets

• nexusai_support_ticket_create: Submit a new support ticket to the NEXUS AI team.
• nexusai_support_ticket_list: List your organization's support tickets.
• nexusai_support_ticket_get: Get the full details and message thread for a support ticket.
• nexusai_support_ticket_reply: Add a reply message to an existing support ticket.

Tech Stack

Reliability

NEXUS AI is built to keep stateful apps alive across host reboots, backend restarts, and manual stop/start cycles. The reliability layer:

• Persistent compose workdirs at /var/lib/nexus/deployments so the orchestrator survives PrivateTmp and tmpfs wipes
• Soft stop semantics: docker compose stop (not down) preserves containers, networks, volumes, and the port reservation
• Boot reconciliation runs 5 seconds after backend startup, verifies every RUNNING deployment is actually running, and restarts any that are down
• Replica preservation across restart: scale state survives stop/start and reboot
• restart: unless-stopped on every container so Docker brings them back automatically

Deep dive: How NEXUS AI keeps your Postgres alive across host reboots.

Security

• Encryption at rest: AES-256-GCM for all secrets, bucket credentials, and sensitive configuration
• Encryption in transit: TLS 1.2+ enforced across all endpoints
• Tenant isolation: per-organization runtime, networks, volumes, and S3 buckets. No shared application runtime or storage between customer organizations.
• Per-bucket IAM: every S3 bucket ships with a scoped MinIO service account, not platform-wide root credentials. Rotatable via nexusai_bucket_rotate_credentials.
• Zero plaintext credentials: Secrets never appear in code, container images, build logs, or runtime logs
• Audit logging: Every action (deployment, secret access, scope use, backup, restore, config change) logged with timestamp, actor identity (user or agent token name), and result
• RBAC + scoped tokens: Role-based access at organization and deployment level, plus fine-grained OAuth scopes for least-privilege automation
• Private runtimes: Enterprise customers run fully isolated build and runtime environments
• IP allowlisting: Network-level access controls for Enterprise deployments

Security overview

HIPAA and Compliance

NEXUS AI provides HIPAA-aligned technical safeguards for regulated healthcare environments:

• Infrastructure isolation: Container-level isolation per deployment. No shared runtime between tenants.
• Audit trails: Deployment history, execution logs, change tracking, agent attribution, and user activity visibility
• Secrets management: Runtime injection only. No plaintext credentials in code, images, or logs.
• Customer-owned cloud: Enterprise customers deploy entirely within their own AWS, Google Cloud, or Azure accounts
• Data residency: Choose specific cloud regions for all workloads
• BAA: Business Associate Agreements available for Enterprise and Healthcare Pro customers
• SSO: SAML / OIDC support for Enterprise (satisfies HIPAA workforce access requirements)
• Network controls: IP allowlisting, private networks, and air-gapped environments for Enterprise

Shared responsibility. NEXUS AI provides HIPAA-aligned infrastructure controls and is designed to support customer HIPAA compliance programs. Customers retain responsibility for their overall compliance posture, application logic, data classification, internal policies, and HIPAA program governance.

HIPAA and Compliance details

Frequently Asked Questions

What is NEXUS AI? NEXUS AI is an MCP-native application platform that builds and deploys full-stack containerized applications (Postgres, MySQL, Mongo, Redis, S3 buckets, persistent volumes, workers, encrypted backups) in 5 minutes, with an AI App Builder, standalone managed databases, and an AI Gateway. Every platform action is callable as an MCP tool, so Claude, Cursor, Codex, and any MCP-compatible agent can deploy, scale, back up, restore, query the database, and roll back without leaving the chat.

Where can I install the NEXUS AI MCP server? The official MCP Registry lists it at io.github.nexusrun/nexus-ai. Also indexed at mcp.so and Smithery. Direct endpoint: https://mcp.nexusai.run/mcp.

Can I build an app inside NEXUS AI? Yes. The AI App Builder turns a prompt into a live preview, supports full-stack Next.js + Prisma apps with a managed database and built-in auth, and deploys through the same pipeline as the CLI. You can also import an existing GitHub repo, push to GitHub, or hand files back and forth with Claude over MCP.

Do databases live and die with my app? No. Standalone managed databases belong to your organization. Redeploying, stopping, or deleting an app leaves the database and its data untouched. Attach and detach at any time.

Which AI tools generate apps that NEXUS AI deploys? NEXUS AI deploys from any Git repository. Apps generated by Claude Code, Cursor, v0, Bolt, Lovable, Replit, Windsurf, or any other tool work the same way: push the result to GitHub and run nexus deploy source --repo <url>.

Where do full-stack deploys actually run? Full-stack deploys (app + databases + storage + workers) run on the NEXUS AI managed Container platform with org-level isolation. Single-container deploys can also target AWS App Runner, Google Cloud Run, or Azure Container Apps.

Does NEXUS AI require a DevOps team? No. NEXUS AI is designed so individual developers and small teams can deploy production-grade containerized applications without dedicated DevOps expertise. The platform handles container builds, deployment orchestration, secrets management, health checks, observability, and the database / storage / backup layer.

Can I deploy from a GitHub repository? Yes. NEXUS AI supports deployments from GitHub repositories, container images, local source code, or AI-generated code through the same unified workflow.

Is NEXUS AI HIPAA compliant? NEXUS AI provides HIPAA-aligned technical safeguards including tenant isolation, AES-256-GCM encrypted secrets, encrypted backups, scoped per-bucket IAM, full audit logs, and customer-owned cloud deployments. BAAs are available for Enterprise and Healthcare Pro plans.

Can I use my own cloud account? Yes. Enterprise customers can deploy NEXUS AI entirely within their own AWS, Google Cloud, Azure, or on-premises infrastructure with no data leaving their environment.

How does rollback work? Every deployment is versioned and immutable. You can restore any previous version with a single click from the deployment dashboard, the CLI (nexus deploy rollback), or an MCP call (nexusai_deploy_rollback). No manual re-deployment or downtime required.

What happens to my secrets? Secrets are encrypted with AES-256-GCM and injected at container runtime only. They are never stored in plaintext, never appear in container images, and never appear in build or runtime logs. A full access audit trail is maintained.

What happens to my data if the host reboots? Persistent volumes survive container restarts and host reboots. Boot reconciliation restarts any deployments the reboot did not bring back. Postgres / MySQL / Mongo crash recovery happens via their own journaling on next start. Full deep dive: How NEXUS AI keeps your Postgres alive across host reboots.

How is NEXUS AI different from Vercel, Render, Railway, or Fly.io? NEXUS AI is the only platform that combines (1) full-stack deploys in one command, (2) 74 MCP tools for AI agents to operate the platform end-to-end, (3) AI-powered database schema fixes from runtime logs, (4) per-bucket IAM out of the box, (5) HIPAA-aligned controls with customer-owned cloud deployments. See the comparison table above.

Reading list

Recent engineering and product posts:

• Your AI app is generated. Now how do you deploy it?. The deploy gap for AI-generated apps and how NEXUS AI closes it.
• MCP-driven deploys: 5 tasks your Claude agent should be running for you. Concrete operations to hand to an agent today.
• From v0 prototype to production database in 5 minutes. Tutorial.
• How NEXUS AI keeps your Postgres alive across host reboots. Reliability deep dive.
• Deploy a full-stack Python app with Postgres, Redis, and workers in 5 minutes. Hands-on FastAPI tutorial.
• Database backup and restore on NEXUS AI. Backup mechanics.

Links

Contact

• Support: support@nexusai.run
• Sales: nexusai.run/contact
• LinkedIn: linkedin.com/company/nexusai-run

© 2026 NEXUS AI, Inc. Built for engineers who ship.