> For clean Markdown of any page, append .md to the page URL.
> For a complete documentation index, see https://platform.bctrl.ai/llms.txt.
> For AI client integration (Claude Code, Cursor, etc.), connect to the MCP server at https://platform.bctrl.ai/_mcp/server.

# Core model

> How Spaces, Runtimes, Runs, and Views fit together.

BCTRL has one simple execution model:

```text
Space → Runtime → Run
             ↘ View
```

The **Runtime** does the work. The **Run** records one execution. A **View**
lets a person watch or influence that work.

## Space

A **Space** is the boundary around your automation. It groups Runtimes and
defines which storage, Vault secrets, and AI credentials they can use.

Use a Space when you need isolation, shared configuration, or a separate
environment for a team, customer, or workflow.

## Runtime

A **Runtime** is the durable resource that performs automation. It represents
the thing being automated. The current SDK creates browser Runtimes; the model
also leaves room for future runtime types such as computers and spreadsheets.

A Runtime belongs to a Space and owns its configuration and identity. Tools,
Agents, and browser connections all operate through a Runtime.

The Runtime response exposes this identifier as `id`. When another resource or
request refers to the Runtime, the field is named `runtimeId`. In the SDK, pass
the Runtime object's `id` to lifecycle methods such as
`bctrl.runtimes.start(runtime.id)`.

## Run

A **Run** is one execution of a Runtime, from start until it stops or fails.

The Run response exposes its identifier as `id`. Run-scoped methods and
responses use `runId`, such as `bctrl.runs.get(runId)`. The Run's trace, events,
recording, and usage all use that Run ID as their observability key.

A reusable Runtime can have many Runs over time. An ephemeral Runtime normally
has one Run.

## View

A **View** is a user-facing surface into a Runtime or Run. It is not another
execution record.

Use a View to:

* watch automation as it runs;
* inspect a recording, trace, or event stream;
* provide input when the automation needs a person; or
* intervene in a live session when the View allows it.

This is usually called **live supervision** or **human-in-the-loop control**.
The Run remains the record of what happened; the View is how a person sees or
influences it.

## Automation

Tools, ToolCalls, Agents, and Conversations are ways to perform work through a
Runtime. They are not additional execution containers:

* A **Tool** is one capability.
* A **ToolCall** is one execution of that capability.
* An **Agent** uses a Runtime to complete a task.
* A **Conversation** is a durable message workflow for an Agent.

Their activity is recorded in the active Run.

## Choose the right resource

* Need isolation or credentials? Start with a [Space](/sdk/spaces).
* Need something to automate? Create a [Runtime](/sdk/runtimes).
* Need the record of an execution? Read its [Run](/sdk/runs).
* Need to watch or influence the work? Create a [View](/sdk/views).