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.
1 — The sandbox
An isolated machine on our compute, with SSH access. It stays up whether or not you are connected. In development.
2 — The agents platform
Agents you create yourself, running for real on sandboxes, with logs and access control. Being designed.
3 — Shared memory
Memory your agents can share, organised around an ontology instead of a pile of files. On the roadmap.
4 — More tools
Whatever the first three make obvious. We would rather ship one thing properly than list ten. Not started.
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.
What people run in it
An agent that has to finish
Start your coding agent in the sandbox, let it work through something long, and close the laptop. Come back later and read the log.
A long build
A test suite that takes forty minutes does not have to survive a dropped connection or a sleeping screen.
A service to point at
A staging API, a fixture server, a database at the exact version you need — reachable and disposable.
Something you would rather not run locally
A package that might misbehave, a script from a stranger, a reproduction you do not want on your own filesystem.
Running it here, versus running it there
| On your laptop | In a sandbox | |
|---|---|---|
| Survives a closed lid | No | Yes |
| Survives a dropped connection | No | Yes |
| Reachable from elsewhere | No | Yes, over SSH |
| Cleanup | Whatever you remember to do | Destroyed, automatically when idle |
| Isolation | Your filesystem, your shell history | A machine of its own |
| The cost of a mistake | Yours to clean up | Gone 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.