Introduction
Understand why Jio gives local AI agents a separate machine for files, tools, and code execution.
What is Jio?
Jio is an open-source runtime that connects a local AI agent to a remote sandbox through MCP. Your model, prompts, conversation history, and agent loop stay under your control. Filesystem changes, dependencies, builds, and commands run on a machine dedicated to the work.
What is Jio for?
Use Jio when an AI agent needs a real development environment to build, test, install dependencies, or run unfamiliar code—but you do not want that work happening on your everyday machine or your agent loop locked inside a sandbox vendor's platform.
Jio is useful when you want to:
- read and update project files outside your everyday development machine;
- execute commands with explicit filesystem, resource, and network boundaries;
- use the MCP-capable client and model you already prefer;
- work in a persistent or disposable environment that matches the task;
- run on infrastructure you can self-host and inspect.
The problem with typical agent sandboxes
Many agent runtimes bundle reasoning and execution into one managed platform. That can make the first demo easy, but it also creates architectural tradeoffs once the agent touches real code.
The agent and runtime are coupled
Using the sandbox can require moving model configuration, prompts, or conversation state into the same hosted platform.
Every client needs a custom adapter
Platform-specific SDKs and tool contracts make the workspace harder to reuse across different agents.
The control plane is not yours
Accounts, license keys, and managed orchestration can sit between you and the machine that executes the work.
One lifecycle is forced on every task
A fixed persistence model makes it harder to choose between a clean disposable run and an ongoing project workspace.
What changes with Jio
Jio is the runtime boundary between your local agent and a remote sandbox. It moves effectful tools to the remote side without replacing the model, client, or agent loop you already use.
| Stays on your machine | Runs in the remote sandbox |
|---|---|
| Model and agent client | Project checkout and generated files |
| Prompts and conversation history | Dependencies, builds, and commands |
| Approval interface and agent loop | Tool processes, artifacts, and services |
| Local identity and trust policy | Enforced resource and network boundaries |
Keep the agent local
Run your preferred model and MCP-capable client where you control prompts, approvals, and conversation state.
Connect through MCP
A small local bridge exposes a consistent tool interface and sends workspace operations to Jio.
Execute inside a remote sandbox
Jio reads files, applies edits, and runs commands within the sandbox's configured identity, resources, and network policy.
Return structured results
The agent receives output, exit status, or a policy rejection and uses that evidence to decide what happens next.
Remote execution is a boundary, not a guarantee
Jio keeps execution away from your laptop, but generated commands and unfamiliar code still need scoped permissions, resource limits, and review.
Why you can verify Jio's claims
Jio is designed to earn trust through inspectable output and fail-closed behavior, rather than asking you to rely on a generic "secure sandbox" label.
| Claim | How to verify it |
|---|---|
| Planning does not allocate compute | Run jio doctor and jio plan with --json; confirm worker_contacted and allocated are false. |
| Trust posture is explicit | Inspect the reported trust and attestation state. Jio does not silently downgrade to a weaker mode. |
| Local files are not overwritten silently | Review jio diff, then use the explicit, conflict-checked jio sync flow. |
| Secret values have a separate input path | Enter values through interactive jio secret set; the MCP surface does not expose a tool for setting secret values. |
Current trust model
Jio Core is pre-release. The current runnable path uses trusted-host mode, which is unattested and operator-readable. The confidential trust mode is not yet available and fails closed instead of falling back automatically.
Learn the runtime
Sandbox
The isolated environment where tools create effects.
Session
The bounded connection between an agent and a sandbox.
Templates
Reusable definitions for creating consistent sandboxes.
Connect an agent
Register the Jio bridge with an MCP-capable client.
Run your first Jio session
Start with the CLI so you can validate identity, trust, environment, and limits before giving an agent remote tools.
Get started with the Jio CLI
Run doctor, inspect the plan, start a bounded session, and execute your first command in a remote workspace.