# Build an AI agent with a real computer. Deploy it as an API.

Salambo turns your agent harness into a versioned, production-ready service.

Deploy the agent's prompts, tools, skills, extensions, software, and working
environment together.

Each run executes in an isolated managed workspace with durable state, protected
credentials, controlled networking, and connected operational evidence. Your
deployed agent is available through the Native Runs API, Slack, Microsoft Teams,
or your own application.

### [Create your first agent](/docs/quickstart)

Initialize a project, write its first behavior, and validate the compiled
deployment manifest.

### [Understand the architecture](/docs/architecture/hosted-runtime)

See how the hosted worker, managed sandbox, durable workspace, and
deployment boundaries fit together.

## Salambo in 30 seconds

```mermaid
flowchart TB
  Source["Agent project<br/>prompts, tools, skills, extensions"] --> Deployment["Versioned deployment"]
  Entrypoints["API, Slack, Teams"] --> Worker["Trusted hosted worker"]
  Deployment --> Worker
  Worker --> Provider["Model provider"]
  Worker --> Sandbox["Managed sandbox"]
  Sandbox --> Workspace["Durable workspace"]
  Worker --> Evidence["Turns, files, events, and traces"]
```

Your project describes the agent's behavior and working environment. Salambo
turns that source into an immutable deployment, operates the model loop in a
trusted hosted worker, and gives the agent constrained hands inside a managed
sandbox.

The run owns its conversation and workspace. The sandbox is replaceable compute:
Salambo can checkpoint the workspace, recreate the sandbox, restore the files,
and continue the run without treating one machine as permanent.

## Where the boundary sits

| You own                                | Salambo operates                                    |
| -------------------------------------- | --------------------------------------------------- |
| Agent behavior and instructions        | Model loop and run lifecycle                        |
| Tools, skills, prompts, and extensions | Isolated sandbox execution                          |
| Required packages and workspace inputs | Durable workspace checkpointing and recovery        |
| Model and runtime configuration        | Deployment builds, activation, and upgrades         |
| Application and business integrations  | Scoped secrets, networking, events, and diagnostics |

Your source never replaces the trusted worker. Customer-authored commands and
extensions execute inside the sandbox boundary, while provider credentials,
deployment authority, and platform control paths remain outside it.

## Why teams use Salambo

### Version the complete harness

Prompts, tools, skills, extensions, packages, model settings, and runtime
configuration move together. Every behavior change connects back to a
reviewable deployment.

### Give every run a durable workspace

Agents work with files, terminals, installed software, and multi-turn state.
Checkpoints preserve that work across sandbox replacement and safe
deployment upgrades.

### Keep controls outside the agent

Salambo controls credentials, networking, provider access, deployment
authority, and platform runtime paths outside customer-authored execution.

### Operate from evidence

Turns, lifecycle events, artifacts, customer-safe diagnostics, and
OpenTelemetry traces stay connected to the run and deployment that produced
them.

## From project to production

### Build the harness

Define the instructions, model settings, active tools, skills, prompts,
hosted extensions, packages, and initial workspace files in one source
project.

### Deploy a versioned release

Validate the project with the CLI, upload the source, and let Salambo build
and activate an immutable managed deployment.

### Call and operate the agent

Use the Native Runs API, Slack, Microsoft Teams, or your own integration.
Review runs, files, Activity, Diagnostics, and exported telemetry from the
same operating surface.

## What Salambo is—and is not

| Salambo is                                           | Salambo is not              |
| ---------------------------------------------------- | --------------------------- |
| A deployment and runtime platform for AI agents      | Another chat interface      |
| A managed working environment for agent execution    | Only a prompt manager       |
| A control plane for releases, runs, and integrations | A model provider            |
| An API and operational layer around agent workloads  | Merely a container launcher |

## Choose your path

### [Build an agent](/docs/agent-development/project-structure)

Learn the project structure for instructions, tools, skills, extensions,
packages, and workspace inputs.

### [Deploy an existing project](/docs/deploy/cli)

Validate, deploy, activate, and smoke test an agent with the Salambo CLI.

### [Integrate a deployed agent](/docs/integrations/runtime-api)

Start or continue a durable agent run with one API endpoint.

### [Operate production runs](/docs/operate/diagnostics)

Inspect lifecycle activity, diagnostics, turns, artifacts, and runtime
evidence.

### [Connect Slack or Teams](/docs/integrations/overview)

Route workplace messages into the same deployed agents used by your
applications.

### [Review the security model](/docs/operate/security)

Understand worker isolation, sandbox permissions, secrets, networking, and
customer-visible evidence.