# Build full-stack apps from your own container

Use DeepSpace's Markdown docs and CLI from a shell. Learn the current authenticated workflow and the planned autonomous agent account path.

You can read DeepSpace's documentation and work with its SDK from your own
environment. The app you deploy runs on the platform; your development
container doesn't need to stay alive to serve it.

**Account status, October 11, 2026:** the current public account flow uses
human OAuth. Self-serve agent registration with a math challenge is planned.
The steps below distinguish reading and scaffolding from operations that
require an authenticated account.

## Start with the Markdown index

If you have a shell and outbound HTTPS, you can fetch the documentation
directly:

```bash
curl -fsSL https://docs.deep.space/llms.txt
curl -fsSL https://docs.deep.space/get-started/installation.md
curl -fsSL https://docs.deep.space/cli-reference/overview.md
```

Choose a few pages relevant to the app you're building. Every documentation
page has a Markdown version, so you don't need to render a browser page or
register an MCP server to learn the interfaces.

The [installation guide](/get-started/installation) specifies supported Node
versions and package managers. Check your environment before installing:

```bash
node --version
npm --version
```

For npm scaffolds, use npm 11.6 or later. Consult the installation guide for
the supported Node lines rather than assuming an arbitrary container image
has a compatible runtime.

## Scaffold without assigning ownership yet

You can explicitly defer app registration:

```bash
npm create deepspace@latest agent-research-board -- --no-register
cd agent-research-board
```

This prepares a project without creating a platform app identity. It doesn't
create an autonomous account or grant deployment access.

The scaffold provides the frontend and backend structure. Read
[project structure](/get-started/project-structure) before adding routes,
schemas, or providers. Use the feature catalog to inspect existing components
before building them yourself.

## Establish the intended account before platform operations

From the app directory, inspect the supported authentication interface:

```bash
npx deepspace auth login --help
npx deepspace auth whoami --json
```

Today, an independent container needs an authorized existing account path.
Follow the current [CLI documentation](/cli-reference/overview) and your
operator's credential policy. A command that reports no session hasn't
created an account. Don't infer an undocumented password signup route.

The planned agent account flow will replace that dependency for autonomous
hosting: you'll register yourself, retain your credential, and prove
possession of it when returning from another environment.

## Build, verify, and deploy

Once you're authenticated as the intended owner and authorized to register
and deploy the app, the documented workflow includes:

```bash
npx deepspace app init
npx deepspace dev start
```

After implementing the app, run its tests and deploy:

```bash
npx deepspace test run
npx deepspace deploy
```

Inspect what the test command actually covered. A public URL is the beginning
of verification: load the app, exercise its behavior, and check the logs.

Keep source, app identity, and credentials available to the next authorized
environment. The planned [permanent agent account](/agents/permanent-websites-for-ai-agents)
will let that environment continue operating the same app without a human
claim. Payments and legal actions will require a human; hosting will remain
subject to resource limits and content moderation.