/ˌæp əˈlɔːft/

Build with agents. Ship with proof.

An open source AI application delivery platform.
From secure agent sandboxes to verified production: run work in isolation, freeze an exact candidate, promote it explicitly, then deploy and verify through one operation catalog.

5-minute example · Website · Cloud · Docs · Releases · 中文

The official appaloft/examples/hello project is a dependency-free Node HTTP app with a Dockerfile, appaloft.yml, /health, and a small JSON API. Clone it and verify the workload before deploying:

git clone --depth 1 https://github.com/appaloft/examples.git
cd examples/hello
npm start

In another terminal:

curl -sS http://127.0.0.1:3000/health

Once Appaloft is installed and a target is selected, deploy the same directory through the one-file configuration:

appaloft deploy . --config appaloft.yml

The full example documents local Docker verification, public Git deployment, Cloud Console setup, health checks, and the exact source/runtime contract.

Appaloft is an open source AI application delivery platform. It connects coding-agent execution and isolated Sandboxes to immutable candidate artifacts, explicit Promotion, production Deployment, and delivery evidence. The existing deployment control plane remains the available production foundation behind CLI, HTTP API, Web console, MCP tools, and the AI skill.

Use Appaloft when you want:

• One appaloft.yml file to describe source, runtime, network, access, dependencies, and deploy intent.
• A local-first workflow that can deploy from a folder, Git repo, zip archive, Docker image, or Compose bundle.
• A repeatable deploy loop: detect, plan, execute, verify, observe, retry, redeploy, or rollback.
• AI-friendly operations without giving agents direct database, Docker, SSH, or provider access.
• Self-hosted control on your own Linux server or VM.

“Delivery Evidence Chain” means Appaloft can preserve and read the observations linking an accepted candidate to a Deployment result. It does not claim formal correctness, security, or compliance.

The API hierarchy makes Runtime ownership explicit: agents belong to a Sandbox. After an operator provisions a Pi- or OpenCode-enabled Sandbox template, an application developer can use the public SDK without running the agent harness in the application process:

import { createAppaloftClient } from "@appaloft/sdk";

const appaloft = createAppaloftClient({
  baseUrl: "https://app.example.com/api",
  auth: {
    kind: "product-session",
    cookie: process.env.APPALOFT_SESSION_COOKIE!,
  },
});

const workspace = await appaloft.workspaces.create({
  sandbox: {
    source: { kind: "template", templateId: process.env.OPENCODE_SANDBOX_TEMPLATE_ID! },
    requestedIsolation: "gvisor",
    limits: {
      cpuMillis: 2_000,
      memoryBytes: 2_147_483_648,
      diskBytes: 10_737_418_240,
      maxProcesses: 128,
    },
    networkPolicy: { mode: "deny", rules: [] },
  },
  harness: "opencode",
});

const run = await workspace.agent.runs.create({
  task: "Build the requested application in /workspace/app",
});

The caller owns chat/session state. Appaloft owns the isolated execution, lifecycle, event readback, artifact boundary, Promotion checkpoints, and production delivery evidence.

See the official Sandbox Agent examples for complete Chat-to-App, human approval, and Preview-to-Promotion flows. Workspace and Agent operations currently use a product session rather than a deploy token.

Resource-handle methods throw AppaloftSdkRequestError on failure. The complete generated, non-throwing operation facade remains available under appaloft.operations.

Install the self-hosted stack on a Linux server or VM:

curl -fsSL https://appaloft.com/install.sh | sudo sh

Pin a release version:

curl -fsSL https://appaloft.com/install.sh | sudo sh -s -- --version 1.0.1

The installer verifies or installs Docker Engine and the Compose plugin, writes the self-hosted stack to /opt/appaloft, and starts the Appaloft backend, static console, and PostgreSQL.

See Providers, Core operations, and the product roadmap for the current public contracts and planned work.

Choose the entry point that matches how you want to use Appaloft.

Create appaloft.yml in your project:

name: my-app
source:
  path: .
runtime:
  method: workspace-commands
  installCommand: bun install --frozen-lockfile
  buildCommand: bun run build
  startCommand: bun run start
network:
  internalPort: 3000
access:
  default: public

Then deploy:

appaloft deploy . --config appaloft.yml

These commands cover the path most teams use day to day.

# Check the installed CLI and local profile
appaloft --version
appaloft auth status
appaloft context show

# Start from a repo, folder, Docker image, or Compose project
appaloft init
appaloft deploy .
appaloft deploy ./dist --config appaloft.yml
appaloft deploy https://github.com/acme/web.git
appaloft deploy ghcr.io/acme/api:1.7.3
appaloft deploy ./docker-compose.yml

# Observe and operate deployments
appaloft deployments list
appaloft deployments show <deploymentId>
appaloft deployments timeline <deploymentId> --follow --json
appaloft deployments retry <deploymentId>
appaloft deployments redeploy <resourceId>
appaloft deployments rollback <deploymentId> --candidate <deploymentId>

# Work with projects, environments, and resources
appaloft project list
appaloft project create
appaloft env list
appaloft resource list
appaloft resource show <resourceId>
appaloft resource logs <resourceId>
appaloft resource health <resourceId>
appaloft resource runtime restart <resourceId>

# Register and prepare servers
appaloft server register
appaloft server list
appaloft server test <serverId>
appaloft server runtime prepare <serverId>
appaloft server capacity inspect <serverId>

# Publish static output directly
appaloft static-artifacts publish ./dist
appaloft static-artifacts publish ./dist.zip

# Use Blueprints
appaloft blueprint list
appaloft blueprint show pocketbase
appaloft blueprint plan-install pocketbase
appaloft blueprint install pocketbase
appaloft blueprint installation show <installationId>

# Dependencies, storage, and scheduled tasks
appaloft dependency list
appaloft dependency inspect <dependencyResourceId>
appaloft storage volume list
appaloft scheduled-task list

# Audit and recovery
appaloft work list
appaloft work watch <workId> --json
appaloft audit-event list --aggregate <aggregateId>

For the full operation list, see skills/appaloft/references/cli-entrypoints.md.

Appaloft MCP exposes the same operation catalog to MCP clients. It is a transport surface, not a separate automation layer.

# Local stdio MCP server
appaloft mcp stdio

# Local HTTP MCP server at /mcp
appaloft mcp serve --host 127.0.0.1 --port 3939

# Dedicated package launcher for MCP hosts
npx @appaloft/mcp
npx @appaloft/mcp serve --host 127.0.0.1 --port 3939

# Browser handoff and Codex bridge for a hosted or self-hosted control plane
appaloft auth mcp login
appaloft auth mcp codex install

Install the Appaloft skill in an AI host that supports skills:

npx skills add appaloft/appaloft --skill appaloft --global --agent codex --copy --yes

Use --agent claude-code for Claude Code. Verify with npx skills list --global --agent <agent> and start a new agent session.

Then ask your agent to deploy or operate a project through Appaloft. The skill tells the agent to use Appaloft operations instead of bypassing the product with direct Docker, SSH, database, or cloud provider calls.

Use the bundled deploy action when CI should deploy over pure SSH or through a self-hosted Appaloft control plane:

name: Deploy

on:
  push:
    branches: [main]

jobs:
  deploy:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4
      - uses: appaloft/appaloft/.github/actions/deploy-action@main
        with:
          source: .
          ssh-host: ${{ secrets.APPALOFT_SSH_HOST }}
          ssh-user: root
          ssh-private-key: ${{ secrets.APPALOFT_SSH_PRIVATE_KEY }}

bun install
export APPALOFT_DATABASE_DRIVER=pglite
bun run db:migrate
bun run dev

For PostgreSQL local development, start docker-compose.dev.yml and set APPALOFT_DATABASE_DRIVER=postgres plus APPALOFT_DATABASE_URL.

Useful development commands:

bun run lint:ci
bun run typecheck
bun run test
bun run build
bun run smoke:local:static

• Self-hosting install
• Architecture
• Core operations
• MCP server
• Providers
• Plugins
• Testing
• Release
• Security
• Agent rules

Apache-2.0.

The open source edition covers this repository's source code. Appaloft Cloud and other hosted service-specific code may be distributed separately under different terms.

The Appaloft name, logo, and related brand assets are not granted by the Apache-2.0 license; see TRADEMARKS.md.