Purpose built for AI Coding

Give your AI coding tool a
production backend

Build. Deploy. Run your app.

Connect Claude Code or Codex

claude mcp add --transport http turnzero-cloud https://turnzero.ai/mcp

Then in Claude Code type /mcp, choose turnzero-cloud, and sign in in your browser.

codex mcp add turnzero-cloud --url https://turnzero.ai/mcp

Codex opens your browser to sign in.

Claude desktop app: open Settings → Connectors → Add custom connector. Enter https://turnzero.ai/mcp, keep “Sign in now” under Authentication. Your first sign-in to Turn Zero creates your free account.

Turn Zero Cloud #

View this page as Markdown

Turn Zero Cloud is the complete production backend that hosts and runs applications built with AI coding agents such as Claude Code and Codex, with everything included on one predictable plan.

It connects to your AI coding tool through a Model Context Protocol (MCP) server. Once connected, your AI can code, build, and test backends, connect them to your app, and host your code in the cloud. Your AI provisions backend services, stores secrets by name, deploys your application, and reads its logs and stats directly. Turn Zero lets you keep coding with AI the way you do now. You can deploy straight to production, or turn on a development environment and promote from it, all from your chat session.

Where to start #

  1. Connect Claude Code or Codex to the platform and sign in.
  2. Use your AI coding tool to create and deploy apps. For example, type: "Create and deploy to turnzero a simple AI chat web app that lets me ask questions, with account sign in."

Features #

Built from the ground up for AI coding tools #

Feature
MCP server for Claude Code and Codex ✓
Tools and APIs provide hints to your AI ✓
Documentation your AI reads directly, written for AIs ✓
Context for each action: what it needs before your AI calls it ✓
Skills: ready procedures your AI can run ✓
An integration guide written for your AI in every feature package ✓
Test doubles, so your AI's tests run offline ✓
A library of feature packages that your AI adds to your project and uses ✓
Scaffolding for your AI ✓
A management plane written for your AI: ask "Why did it fail?" and it reads the logs, counters, and deploy steps ✓
Permanent deletes require your approval ✓
Send feedback to Turn Zero from your chat session ✓

Deploy and run #

Feature
Node.js hosting for your built app, at its own address under ai.host ✓
Your own domain for a Pro application's production environment, with two DNS records ✓
A production environment, and a development environment when you want one: deploy, promote, roll back, restart, version history, pause and resume ✓
A health check before each new version takes over; a failed deploy leaves the running version serving ✓
Unattended deploys from a continuous integration (CI) job, on a limited token ✓
Local runs on your own machine, before you deploy ✓
Scheduled jobs, with each run's outcome recorded ✓
Egress firewall: your app reaches only the hosts you declare, watched first, then enforced ✓
Request limits: a time limit on every request ✓
Per-address and per-user rate limits on every request ✓
WebSockets for apps that declare them, open beyond the request deadline within their limits, and streamed responses up to it ✓
Runtime isolation: each app runs in its own container, with its own credentials, secrets, database, and files ✓
One API for your AI coding tool, your scripts with limited, revocable tokens, and the turnzero.ai dashboard ✓
A Free, Standard, or Pro plan for each application, and its usage for the month, read from your tool or the dashboard ✓
Export of each application's database and files, and account deletion with your approval ✓

Backend feature packages #

Feature
Accounts for your app's users: sign-in with Google, GitHub, a passkey, an emailed code, or a work account (Microsoft SSO), with sessions, invitations, and open or invitation-only sign-up ✓
End-user management from your AI session: invite, list, suspend, and delete your app's users ✓
Database: PostgreSQL for each environment, with migrations ✓
File storage: named areas ✓
Short-lived upload and download links, so your app moves files straight to and from storage ✓
Secrets stored by name without passing through your chat, write-only; an outside API's key is replaced without a redeploy ✓
External API calls on your stored keys, streaming included ✓
AI allowance included; also bring your own AI key ✓
Logging, and hosting safeguards: request checks and time limits ✓
Push notifications to iPhone and Android ✓
Email from your app: confirmations, receipts, and invitations, without running a mail provider (Pro plan) ✓
Issue tracking and feedback inside your app ✓

Web app backends #

Feature
Your web client's files served beside your backend, at the same address: its page, scripts, styles, fonts, and images, with no backend action per file ✓
Browser sign-in held in one session cookie on your app's own address: HttpOnly, Secure, and SameSite=Lax, carrying a signed session token the Account package verifies ✓
Ready-made sign-in pages on your app's own address, under /__account/, so your AI builds no sign-in screens ✓
A sign-in gate for invitation-only and work-account apps: a visitor without a session goes to the sign-in page, and an API call is refused 401 ✓
Cookie isolation: your app's own cookies stay on its own address, the platform removing any Domain attribute ✓

Mobile and desktop app backends #

Feature
Native sign-in: standard mobile OAuth, Sign in with Apple, and Google sign-in ✓
Sessions that last months, and token authentication on every request ✓
Universal and app links ✓
A minimum supported app version ✓
From inside your app, a user registers a passkey, ends a session, and deletes the account ✓
Desktop apps for macOS and Windows sign in through the system browser, as native clients (OAuth/PKCE) ✓

The served version #

These pages describe one version of Turn Zero Cloud. Its number is in the page manifest, on the management contract's source page, and in every action's result as contract_version.

How it works #

Your AI coding tool writes the app; Turn Zero Cloud runs it, with hosting, database, sign-in and scaling included. Your tool writes, builds, and tests the application on your computer. The platform installs its runtime dependencies, builds the hosting image, runs it in production at the application's address, and records its logs, counters, and usage. A development environment is optional: once turned on, each deploy runs there first and a promote moves a version to production. Applications and environments explains the environments.

Three kinds of caller use the same actions: your AI coding tool through the MCP server, a script or pipeline through the HTTP API with a minted token, and you through the signed-in website. Each page shows the actions it uses in backticks, such as deploy and store_secret, as they appear in your tool. Each application has one plan; the pricing page gives prices and included capacity, and How the plans differ technically compares where each plan runs.

What the platform does not do #

The platform does not build your source, approve destructive actions for you, or make your application portable on its own.

Machine surfaces of this documentation #

This documentation is published at https://turnzero.ai/cloud/. An AI coding tool can read it without a browser through four machine surfaces:

  • The index, at https://turnzero.ai/cloud/llms.txt, has one line per page with the page's title, address, and description.
  • The whole text, at https://turnzero.ai/cloud/llms-full.txt, contains every page except the generated reference, which is read page by page.
  • The page manifest is at https://turnzero.ai/cloud/docs.json.
  • The Markdown copy of a page is at the page's address followed by index.md.

A fetch tool that summarizes what it reads, such as Claude Code's WebFetch, can leave pages out of its summary of the index, which lists every page. To find the page for a task, read Find the guide for a task, search the whole text, or, signed in, call read_documentation with a query.

At the origin root, https://turnzero.ai/llms.txt opens with what Turn Zero Cloud is and the site's public pages, then indexes this documentation tree, the pages under /cloud/. It also indexes the Turn Zero Docs tree, the pages under /tzdocs/. https://turnzero.ai/llms-full.txt contains the whole text of every documentation tree that every account can read. https://turnzero.ai/sitemap.xml lists every public page's address, the pages of this tree among them. Each hand-written page there carries the date its text last changed. The navigation beside each page lists pages alone, so these files do not appear in it, and their addresses do not change.

Every account can read this tree. The Turn Zero Team (tzTeam) tree is open only to an account with tzTeam access.

Turn Zero's production site is public, open to every visitor and to search engines. Its development site is private. Where a site is private, what a request receives depends on how it is sent:

  • A browser opening a page, a request that sends Sec-Fetch-Mode: navigate or Sec-Fetch-Dest: document, receives the invitation notice. The response is 401 with a WWW-Authenticate header that mentions the request header Turnzero-Show-Page.
  • The same browser request for a machine surface receives 404 with not found, never the notice.
  • Any other request, such as a tool's fetch, a script, or curl, receives a documentation page or a machine file, marked X-Robots-Tag: noindex, nofollow. The site's own pages, such as / and /pricing, answer it 401 unless it sends Turnzero-Show-Page; the terms and the privacy policy answer it.
  • A request that sends Turnzero-Show-Page with any non-empty value always receives the page or the file, and a Turn Zero Cloud bearer token always receives a machine file.

A tool signed in to Turn Zero Cloud reads the index as the resource docs://cloud/llms.txt and the whole text as docs://cloud/llms-full.txt. With the read_documentation action it also reads one page, one section, or the sections that match a few words, so it needs no download. Reading this documentation as a tool explains reading a long page in parts, going straight to a section, and searching.

The glossary defines each term this documentation uses, once. What happens without asking lists what your tool does on its own and which actions it asks you about first. The refusals page lists all of the platform's refusals, with the cause and remedy of each; a backend package's own failures are listed on its package page.

tzTeam is the companion plugin for keeping requirements, decision records, and raised items in files you own. Its documentation is a separate tree on this site, at /tzteam/, open to an account with tzTeam access.