Yes. Dejima is free and open source under Apache 2.0. You run it on hardware you already own, so there is no subscription and no per-second usage bill. You bring your own agents and API keys, and pay only your normal LLM provider costs.

Dejima free · open source

Manage a fleet of agents on your Mac mini, Linux box, local folder, or cloud.

Isolated projects, persistent sessions.
On your hardware.

Run your coding agents without the tmux-and-SSH grind, and without handing them the whole machine.

Run it yourself → Ask AI if it fits

Session resume

Run dejima, hit enter on a project, and every agent in it opens at once, one window each. Close the laptop and they keep working; reattach from any device and the screens are where you left them. Switching projects is another keystroke, not another SSH login.

Secure sandboxing

Rogue agents can't break out. Each project is sealed in its own island, with no reach to your host machine, your files, or your other projects. Run several agents inside one, each on its own git worktree. Host files and MCP servers are gated: deny-all by default, opened one grant at a time. Outbound traffic is attributed to the island that made it and logged, and you can switch any island to an allowlist.

Fleet management

Status, CPU, memory, and token cost per session, for every agent at once. Summon it from inside a session to see what else is running, then drop back in; the agent never notices. Hibernate what's idle, wake what isn't, and jump between projects with a keystroke.

Clipboard and file transfer

A remote shell normally costs you the clipboard and drag-drop. Here Ctrl-V pastes a screenshot straight to the agent, dragging a file onto the window uploads it, and pointing it at any local path does the same. The agent gets the in-island path; dejima cp moves work back out. No scp.

Works with Claude Code, Codex, OpenClaw, or any command you supervise. Point it at frontier APIs, or at open-weights models running on your own box through Ollama.

Still SSHing into tmux to run your agents? Read the full story. Working with others? Onboard a teammate to their own private fleet, without sharing your box.

Every session starts the same way: dejima

The Dejima TUI: a live dashboard listing islands (dejima, janus, wildfire) and the agents running in each — with status, memory and CPU use, and a detail panel for the selected island.

Is Dejima right for you?

Open in Claude → Open in ChatGPT → Opens in your own AI — nothing is sent to us.

The hard parts of running agents, already handled

You shouldn't have to become an infrastructure engineer to run agents safely. That usually means wiring up containers, networking, credentials, and session plumbing yourself. Dejima is that layer, already built — and it rests on three things:

Ease. One line installs it; run dejima and the TUI walks you to a sandboxed agent in minutes. It manages the containers, sessions, git worktrees, and logins so you don't — on your Mac mini, a VPS, or your own cloud VM, same one command.
Security. Every project is walled off from your machine, your files, and your other projects; host access is deny-all, granted explicitly and read-only. The LLM calls go out, but your code, files, and auth never leave your box — auth is your Tailscale identity, not a vendor account. It fits NDA, regulated, and client-confidential work in a way a managed cloud can't.
Audit. Every privileged crossing is written to a tamper-evident, hash-chained ledger you can read, export, and verify — so you can prove what an agent did, not just hope.

Running agents for a team that has to prove what they did? See Dejima for teams →

Everything you need to run a fleet safely

Past the four above, this is what you get for running agents on your own box.

Brokered host access

Grant an island one host folder, read-only. Everything else stays invisible.

Brokered MCP servers

You curate which MCP servers exist. An island reaches one only once you grant it.

Egress visibility

See every host an island reaches. Put it on an allowlist when you want one.

Audit trail

Every brokered crossing is hash-chained, and verifiable after the fact.

Agent messaging

Agents in an island hand off work to each other with dejima msg.

Cost and token tracking

Spend and token counts per agent, for the session it's in, next to everything else.

Local open-weights models

A curated, hardware-aware catalog. Islands share one Ollama backend on your box.

Scheduled wakes

Wake a hibernated island on a timer and hand its agent the task to run.

Also in the box: headless agents (OpenClaw, Letta, your own loop) alongside terminal ones · lifecycle verbs (hibernate · wake · reset · upgrade · purge) · roles and invites for a shared server · one-key updates that move the client and daemon together · an HTTP/WebSocket API and webhook events to build on.

The isolation of a cloud sandbox, on hardware you own

You're probably weighing Dejima against however you run agents today. Here's where it lands:

What you need	Dejima	Coder	E2B	Rivet	tmux + SSH	A dev container
Isolated workspace per project	✓	✓	✓	✓	✗	✓
Several agents at once, one dashboard	✓	$	✗	✗	manual	✗
Agents sandboxed from your host machine	✓	✓	✓	✓	✗	~ (from host)
Survives disconnect, multi-device	✓	✓	✗	~	✓	✗
Runs where you put it — local or your own cloud	✓	✓	$	✓	✓	✓
Audit log of host-file access	✓	✗	✗	✗	✗	✗
Curated MCP servers, brokered & audited	✓	✗	✗	✗	✗	✗
Managed local open-weights models (via Ollama)	✓	✗	✗	✗	manual	manual
Up in minutes, nothing to build	✓	✗	~	~	~	✓

$ = available only on a paid plan.

How Dejima compares to Coder, Daytona, and E2B, in depth →

One host. Many sealed islands.

How Dejima works: you drive it from a CLI, TUI, or your own app over a websocket + HTTP API on Tailscale. That reaches the Dejima host — a Mac mini, VPS, or cloud VM — which holds islands: 'web' running claude-code, openclaw, and a shell; 'api' running codex, letta, and a headless agent. Each island is one container, sandboxed from the host and from the other islands; the agents inside one island share it, each with its own git worktree.

Text version

        CLI · TUI · your app                 (you drive it)
                    │
                    │  websocket + HTTP API · over Tailscale
                    ▼
┌─ Dejima host · Mac mini / VPS / cloud VM ──────────────────────┐
│                                                                │
│   ┌─ island: web ──────────┐    ┌─ island: api ──────────┐     │
│   │ a1  claude-code        │    │ a1  codex              │     │
│   │ a2  codex              │    │ a2  claude-code        │     │
│   │ a3  headless           │    │                        │     │
│   └────────────────────────┘    └────────────────────────┘     │
│                                                                │
│ per island: one container · shared home + credentials          │
│ per agent:  own git worktree · shares the island with its peers│
└────────────────────────────────────────────────────────────────┘

An island is one container holding one or more agents. They share the workspace, credentials, and tool-auth, but each works on its own git worktree — so they collaborate without clobbering each other. Islands can't see each other; that blindness is the security boundary.

Run almost any agent. Each island holds a mix of two kinds:

Terminal agents you attach to — Claude Code, Codex, or a plain shell (an empty, sandboxed terminal). A host-side bridge wires your session to the agent's tmux inside, so it survives disconnect and multiple devices share one screen.
Headless agents that run on their own — runtimes like OpenClaw, Letta, and Hermes, or your own SDK loop or worker. Output is captured to dejima logs.

Both get the same isolation, lifecycle, events, and one-API management — bring your own keys and mix vendors freely.

Guides

Short, practical walkthroughs for getting a fleet running on your own box.

Turn a Mac mini into an AI agent server (5 minutes, free)

Install once, then run Claude Code, Codex, and OpenClaw contained on a mini in the closet.

You're still SSHing into tmux to run your agents?

Where the tmux + SSH setup breaks down, and how to run a contained fleet on the same box.

All guides → · Use cases →

Common questions

Is Dejima free?

Yes. Dejima is free and open source under Apache 2.0. You run it on hardware you already own, so there's no subscription and no per-second usage bill. You bring your own agents and API keys, and pay only your normal LLM provider costs.

Does my code leave my machine?

No. Your source, your files, and your credentials stay on your own box. The agents' model calls go out to whatever LLM provider you use, but there's no Dejima cloud in the loop and no vendor account holding your work. Auth is your own Tailscale identity.

Which AI coding agents can I run?

Terminal agents you attach to, like Claude Code, Codex, or a plain shell, and headless runtimes like OpenClaw, Letta, and Hermes, or your own SDK loop. You bring your own API keys and can mix vendors freely across islands.

What hardware do I need?

A Mac mini, a Linux server or VPS, a cloud VM in your own account, or just your laptop. Two cores and 4 GB of RAM run a few agents comfortably. The same one install command works on all of them.

How is this different from a cloud agent sandbox?

Services like E2B and Daytona run your agents on their infrastructure and bill by the second. Dejima runs on hardware you own, for free, with persistent sessions you attach to, a dashboard, brokered host access, and an audit log. Your code never leaves your perimeter.

Run a fleet on your own box

On one machine, or on a server you drive from your laptop. One line to install, one word to run. Alpha and open source.

Get started →

Dejima was an artificial island built in 1636 in Nagasaki Bay to serve as a quarantined trading post for foreigners during Japan's period of isolation — one gated bridge to the mainland, every crossing logged. Your agents run the same way: contained on the island, reaching your machine only through a broker that records what crossed.

Isolated projects, persistent sessions.On your hardware.