# The sandbox Perplexity opened, and the open-source system above it

> Perplexity made SPACE, the sandbox platform underneath Perplexity Computer, public on 15 October 2026. Sandboxes are where agent code runs; the agent that decides what to run stayed inside the product. Kortix is the open-source AI Operating System, and the agent layer is the part it publishes as files.

URL: https://opensourceperplexitycomputer.com/perplexity-space-sandbox

## What a SPACE sandbox does, in its own README

`README`

```
Your application
    |
    +-- Create sandbox from template --> Wait for readiness
    |
    +-- Create command session --------> Attach to start the process
    |                                    Read output and exit result
```

Source: https://github.com/perplexityai/SPACE

The lifecycle the repository documents for every sandbox, from github.com/perplexityai/SPACE.

## What Perplexity published on 15 October

SPACE is short for Sandboxed Platform for Agentic Code Execution. It is Rust code that boots a Firecracker virtual machine per workload behind an HTTP API. An application requests an environment from a template and runs commands inside it. Output streams back, and the machine pauses or disappears on request ([repository](https://github.com/perplexityai/SPACE), read 19 October 2026). Templates are the reusable starting image; a sandbox is one live instance with its own filesystem. Idle sandboxes suspend themselves after six hours without activity, and that is a pause rather than a deletion.

What shipped is battle-tested rather than illustrative. Perplexity swapped out its commercial sandbox vendor for SPACE in July 2026, and every Computer session has executed on it since. The company cites millions of creations a day, running three to five times faster than the vendor it replaced on identical traffic ([announcement](https://www.perplexity.ai/hub/blog/open-sourcing-space)).

The checkout is bigger than the daemon. Documentation covers a Kind cluster on one machine, plus an architecture note for teams that run without Kubernetes and an EKS reference deployment. Warm pools keep pre-booted sandboxes on the shelf, base snapshots rebuild one on a single node, and E2B-compatible shims mean existing agent code keeps working.

Security got published too. Perplexity ran an evaluation with root inside a sandbox and told the agents to reach the host. All 108 attempts failed to break the virtual machine boundary. Several runs did route around network rules, and Perplexity says it closed both routes and that a retest beat neither.

## The sandbox is public, the agent stays closed

A subscriber's money does not buy a sandbox. It buys the agent, the model router that chooses a model per query, the connector catalogue, and Projects. It also buys the Automations that wake the agent on a schedule or on an event in Slack, Gmail, Outlook, Linear or GitHub ([Automations](https://www.perplexity.ai/hub/blog/computer-adds-automations-for-ongoing-work), 29 September 2026). None of it is in the checkout.

The README draws the line itself. "Your application decides what to run and what results to keep; SPACE manages the sandbox, its processes, and the connection carrying command output."

Which layer a company can inspect matters more than how much of the stack Perplexity opened. A sandbox constrains reach and nothing else: it has no view on the job, the files, or the person who signs off. Those live in the part that stayed proprietary, and customers meet them as settings.

## What running SPACE yourself takes

The install does not flatter you. The host must be apt-based Linux on x86_64 with KVM, loop devices, btrfs and a Docker daemon allowed to run privileged work. The walkthrough deploys into a Kind cluster, and it does not work on macOS ([installation guide](https://github.com/perplexityai/SPACE/blob/main/docs/installation.md)). What you end up with is an execution environment, an API and a compatibility layer for existing E2B code.

For a platform team that already owns an agent, that is a decent afternoon's work and a real capability. For a company that wanted Computer's behavior, it hands back nothing that decides. There are no prompts, no skills, no memory of last week, no connector grants and no review step.

## The agent layer, as files you own

Kortix is the open-source AI Operating System, and the agent layer arrives as a repository. Each agent's prompt and tool rules live in a markdown file, and the manifest at the root decides what that agent may touch. Skills, accumulated memory, connector declarations and schedules sit beside them in the same checkout ([Kortix on GitHub](https://github.com/kortix-ai/suna)).

```yaml
# kortix.yaml
agents:
  support-triage:
    file: agents/support-triage.md   # what it does, in plain markdown
    connectors: all                  # what it may reach
```

Isolation runs one step further out: one isolated sandbox per session, each with its own isolated machine and branch. Review sits in the repository instead of a console, so a diff is the approval step. The sandbox provider is a setting rather than a vendor's decision.

A team that wrote its own agent and wants a hardened place to run it has SPACE, and that is a fair answer. A team that wanted the agent, its reach into other tools and its memory as text it owns is looking for Kortix. [The self-hosting guide](/self-hosting) has every step.

## Kortix and SPACE, layer by layer

Two open-source releases at different heights of the same stack. SPACE cells come from its repository and Perplexity's announcement, Kortix cells from its docs, all read 19 October 2026.

| | Kortix (recommended) | Perplexity SPACE |
| --- | --- | --- |
| Open source | Yes | Yes |
| What it is | The open-source AI Operating System for agents, memory and triggers | Perplexity's sandbox platform, published 15 October 2026 |
| What arrives as code | The agent files: prompts, grants, memory and triggers | The sandbox, its API, docs and E2B wrapper |
| What you still need | A host and a sandbox provider key | An agent of your own to run |
| Where a job is defined | In the repository, as markdown and yaml | Inside Perplexity's product, outside the release |

## What buyers ask about the SPACE release

Each answer is dated and sourced, read in October 2026.

### Did Perplexity open-source Computer?

No. It published SPACE, the sandbox platform that runs Computer's code ([announcement](https://www.perplexity.ai/hub/blog/open-sourcing-space)). Computer's agent, its model routing and its connectors were not part of the release and stay subscription-only.

### Where is the SPACE code?

At [perplexityai/SPACE](https://github.com/perplexityai/SPACE), public since 15 October 2026. It carries the platform's Rust source, a documentation set, a Kind install guide, a reference EKS deployment and an E2B compatibility wrapper.

### Can I build my own Computer with SPACE?

You can build the execution half. SPACE runs code in isolated virtual machines and manages lifecycles, and its README leaves the decision of what to run with your application. The planner, the routing and the connectors stay with Perplexity.

### What is the open-source alternative to Perplexity Computer?

Kortix. It ships the layer SPACE leaves out as one repository: agents, skills, company memory, triggers and connectors, each session on its own isolated sandbox, and finished work landing as a change request somebody reviews.

## The floor is public. Own the agent layer

SPACE runs the code and leaves the decision to your application, which its README says outright. In Kortix the decision is an agent file and its grants in kortix.yaml, both in the repository the team holds.

[Try Kortix](https://kortix.com) · [The self-hosting guide](https://opensourceperplexitycomputer.com/self-hosting)

Open-source AI Operating System: your agents, skills, memory, and connectors in one repo you own. Any model. Self-host or cloud. Not affiliated with Perplexity, Anthropic, OpenAI, NVIDIA or Manus. Perplexity Computer, Claude Cowork, ChatGPT Work and the other product names on this site belong to their owners.
