Now building — the sandbox

TNTHubThe trusted AI-native toolkit

The trusted AI-native toolkit.

TNTHub gives you an isolated machine with SSH access. You get a shell, you run your own commands, and your agent keeps working when your laptop closes. That is the first piece. Next come a cloud platform for the agents you create, and memory they can share.

Free to use. No account required.

A toolkit, built in order

Four pieces. We build them from the bottom up, and every page says which one is ready.

Start with the sandbox

A machine of yours, on our compute, with a shell. Nothing more is imposed on you.

A sandbox comes up with an SSH server already running. You connect through the platform and you run your own commands — there is no runtime layer, no agent lifecycle manager, and no opinion about what the sandbox is for. The default image has the usual build tooling in it; anything else you need, you install.

# Create a sandbox
tnt box create --name research

# Open a shell in it
tnt box ssh-proxy ssh research

# Run one command and come back
tnt box exec research -- npm test

# Throw it away
tnt box destroy research

tnt box ssh-proxy ssh starts a local proxy that carries the connection and hands you an ordinary SSH session. Your editor, your terminal multiplexer, scp and your ~/.ssh/config all work exactly as they do against any other machine — and the sandbox never needs an inbound port on the public internet.

Why it exists

The problem is small, concrete, and has annoyed every person who runs an agent on a laptop.

An agent stops when your laptop sleeps. You close the lid to go and do something else, and the work stops with it — not because the task failed, but because the machine underneath it went to sleep. You come back and start again, having lost whatever context was only in the process.

Put the agent in a sandbox and the sandbox does not care whether your laptop is open. That is the whole first piece, and it is worth having on its own.

Running it here, versus running it there

On your laptopIn a sandbox
Survives a closed lidNoYes
Survives a dropped connectionNoYes
Reachable from elsewhereNoYes, over SSH
CleanupWhatever you remember to doDestroyed, automatically when idle
IsolationYour filesystem, your shell historyA machine of its own
The cost of a mistakeYours to clean upGone with the sandbox

What comes next

The sandbox is the substrate. Everything else we build sits on top of it.

Next is the agents platform: you define an agent — its model, its instructions, its tools, the sandbox it works in — and the platform runs it, keeps it running, and shows you what it did. That is the point where a sandbox stops being a machine you drive and becomes a machine that runs work for you.

After that comes shared memory: a memory layer your agents can share, organised around an ontology so that what one agent learned is legible to the next one, instead of being another pile of files nobody can read. And then more tools, chosen by what the first three make obvious.

None of that exists yet. Here is exactly what does, what is being built, and what is still only a direction.

Under the hood

A dedicated machine

A sandbox is not a shared container with your neighbours in it. Two sandboxes do not share a filesystem, and neither can see the other’s processes.

Reachable, not exposed

You connect out to the sandbox; it never listens on a public port. There is no inbound firewall rule to get wrong.

Idle reclamation

A sandbox nobody touches for the idle window is torn down automatically, and its contents go with it. We publish the window in the open.

Snapshots

A reclaimed sandbox can be re-provisioned from its snapshot, which is fast, because the snapshot and the machine image are immutable.

What “trusted” has to mean here

It is a claim, so it needs a definition you can check rather than take on faith.

We do not take custody of your code

Your code goes in and comes out under your control, over your own SSH session. We keep the operational metadata needed to run the machine, and nothing more.

We do not read what you run

We do not capture command output and we do not read the filesystem of a running sandbox. If your agent works there, that work stays yours.

We say what is real

Every page in these docs carries a label: built, being designed, or on the roadmap. When something is not ready, it says so before you find out by clicking.

Isolation is the product, not a footnote

One sandbox, one owner. No network path between sandboxes. The boundary is documented in detail — including the parts it does not cover.

What it does not do

We would rather state the limits plainly than let you discover them later.

It is not a place to keep things

A sandbox is disposable. Use it for work, take your results out, and destroy it. Nothing is inherited by the next person or the next tenant.

It does not manage your agent — yet

Today there is no runtime layer. Your agent is a process you start; when it exits, it exits. Agent lifecycle management moves up a layer when the agents platform arrives.

It is not a shared team environment

A sandbox belongs to whoever created it. Sharing one means sharing credentials, which means losing the boundary that made it useful. Multi-agent work gets its own answer, in shared memory.

It is not an agent framework

We are not competing with the tool you already run your agent with. The sandbox gives that agent a place to work that is not your laptop, and gets out of the way.

Frequently asked questions

Do I need an account to use it?

No. The tnt command talks to the platform API directly. If you can reach the API, you can create a sandbox. Getting started does not mean creating an account.

What can I run in a sandbox?

Whatever you want. The default image ships with the usual build tooling and a package manager; anything else you install yourself, and it persists for as long as the sandbox lives.

What happens to my files when the sandbox goes away?

They are gone. Destruction is not a soft delete and there is no recycle bin. Take out anything you want to keep before you destroy a sandbox.

Is the agents platform ready?

No. The sandbox is the first thing we are building and it is being built now. The agents platform comes after it, and the roadmap says plainly which parts are which.

Can I use it with an existing codebase?

Yes — over SSH, with the tools you already use. Your editor, your terminal multiplexer, scp and git all work the way they do against any other machine.

Why start with a machine instead of the agents?

Because the machine is the hard part, and everything above it needs the same substrate: an environment that is isolated, reproducible, disposable, and that you can always get a shell into. The roadmap explains why this order.

Start with one thing that has to keep running

Find the task you have been re-running because your machine went to sleep. Put it in a sandbox.