Unified Workspace

One File System. Every Tool. Seamless Workflows.

A persistent 3-folder file system where built-in capabilities, plugins, and connectors all work together—enabling true multi-tool collaboration within each session.

Shared File Access

What is the Unified Workspace?

A session-isolated file system accessible to all capability types

Agents get a persistent file system that lasts throughout their session. Built-in capabilities (Files, VirtualMachine, CodeRunner) and custom plugins directly access the same storage, while connectors can use it via the Files capability through MCP protocol.

/input/

Read-only

Session context and uploaded input files

/working/

Read-Write

Scratch space for intermediate files and processing

/output/

Read-Write

Final results and generated artifacts

No data copying. No context switching. Just seamless file flow across your entire capability stack.

Universal Access

How Every Capability Type Connects

Built-in capabilities, plugins, and connectors all work with the same files

Files

MCP tools for direct file operations—read, write, list, copy, move, and delete. Agents can manage files programmatically without shell access.

VirtualMachine

Full Linux VM with workspace mounted as native filesystem. Run shell commands, install packages, and use any Unix tool—all changes sync instantly.

CodeRunner

Execute Python and JavaScript with standard file I/O. Use native language APIs (open, pathlib, fs) to read and write files directly.

Plugin Capabilities

Custom WASM plugins access workspace through WASI filesystem interface. Write in any language, use standard file APIs—it just works.

Connector Capabilities

Remote integrations access workspace by invoking the Files capability via MCP protocol. Same permissions, same file operations.

Multi-Tool Workflows

How Tools Work Together

Real-world example of cross-capability file sharing

Input Arrives

User uploads a CSV file. It appears in /input/data.csv—accessible to all capabilities.

Python Processing

CodeRunner executes Python to read /input/data.csv, process it, and write JSON to /working/processed.json.

Custom Plugin Transform

A custom WASM plugin reads /working/processed.json, applies business logic, writes to /working/transformed.json.

VM Generates Report

VirtualMachine runs a shell script that reads /working/transformed.json and generates /output/report.pdf.

Files Tool Delivers

Files capability reads /output/report.pdf and returns it to the user. All steps shared the same storage.

Architecture

Technical Foundation

Built on cloud-native storage with session isolation

Session Isolation

Each session gets its own isolated namespace. Complete separation between concurrent sessions with automatic cleanup when sessions end.

Permission Enforcement

/input is read-only across all capabilities. /working and /output support full read-write operations. Scope-based validation at every access point.

WASI Integration

Plugins access workspace via Wasmtime WASI filesystem interface. POSIX-like API with pre-opened directories. Native language file I/O just works.

Real-World Applications

What You Can Build

Multi-stage workflows that span different capability types

Data Processing Pipelines

Extract data with Python, transform with custom plugins, generate reports in VM, deliver via Files.

/input/raw.csv → /working/processed.json → /output/report.xlsx

Content Generation

Fetch data with connectors, process with CodeRunner, render with plugins, package in VM.

/input/template.md → /working/filled.md → /output/final.pdf

Code Analysis & Building

Upload source to /input, analyze with plugins, compile in VM, store artifacts in /output.

/input/src/ → /working/build/ → /output/app.wasm

Media Processing

Upload media files, process with specialized plugins, apply effects in VM, export to /output.

/input/video.mp4 → /working/frames/ → /output/processed.mp4

Developer Experience

Familiar APIs, Zero Configuration

Python in CodeRunner

with open('/input/data.csv') as f:
  data = f.read()

# Process data...

with open('/output/result.json', 'w') as f:
  f.write(result)

Shell in VirtualMachine

# Paths are identical to file tools
cat /input/config.json

# Process with any tool
jq '.' /input/data.json \
  > /working/filtered.json

# Generate output
pandoc /working/doc.md \
  -o /output/report.pdf

Rust in Plugin

use std::fs;

// WASI filesystem interface
let data = fs::read_to_string(
  "/input/data.json"
)?;

// Process...

fs::write(
  "/output/result.json",
  result
)?;

Standard file APIs in every language. No special SDKs. No configuration. Just works.

Platform Benefits

Why Unified Workspace Matters

True Multi-Tool Workflows

Chain different capability types together seamlessly. Python → Plugin → VM → Connector. Files flow naturally between tools.

No Integration Overhead

All capabilities share the same storage by default. No API calls to transfer data. No serialization between steps. Just file paths.

Session Isolation

Each session operates in complete isolation. No cross-session access. Automatic cleanup after session ends. Perfect for multi-tenant scenarios.

Language-Agnostic

POSIX-like file APIs work in Python, JavaScript, Rust, Go, TypeScript. Use standard library functions. No platform-specific code.

Ready to Build Multi-Tool Workflows?

Start with our free tier and experience seamless file sharing across all capability types. No credit card required.

Start Free Trial Explore Capabilities