agentos
Runs disposable local environments as Ubuntu Docker containers with SSH, terminal, browser, git, and dev servers; used as a local VM provider.
Clones GitHub repositories into environments and pushes branches through a git gateway using per-repository deploy keys or tokens, keeping credentials on the node.
Rents and manages Hetzner Cloud VMs as short-lived environments, including server size selection, snapshot/image builds, and API token setup.
This server does not currently have a deployable release on Glama. Follow the repository's setup instructions to install and configure it for your MCP client, including any required credentials and local dependencies.
openajar was called agentos until November 2026 (legacy-name). Your setup keeps working: see the names that stay and run the installer again to upgrade.
Is it for you?
openajar is for people who already use an agent (Claude Code, Codex, T3 Code or any MCP client) and want it to have a computer of its own, one that is still there tomorrow:
✅ A computer that stays. Its installs, its branch, its dev server and its browser are there in the next chat. It saves itself when idle, so a quiet computer costs cents a month.
✅ A browser it can stay signed in to. It opens the accounts it works with (a dashboard, an admin page, a test shop) and acts there when the work needs it. Logins come from your own vault, and the model never sees them.
✅ Run the app and check it in a real browser, instead of saying it should work.
✅ Desktop apps too, not only web pages. It can open a program on its machine's desktop and use it with a real pointer and keyboard, while you watch.
✅ Keep your laptop out of it. Installs, builds, Docker and dev servers run on the machine, and no key sits there.
✅ One computer per agent. Several agents work at once, each on its own machine, so they never fight over ports, branches, cookies or
node_modules.✅ Use its own shell on the machine:
ssh openajar-<id>,rsyncandscp, as if it were local.
It is not another agent, chat or IDE. Your agent stays where it is, and openajar gives it a computer.
Related MCP server: instanode-mcp
Install
One command on macOS or Linux. It installs the latest release, then walks you through setup in the terminal.
curl -fsSL https://openajar.com/install.sh | shSetup takes about five minutes: paste a Hetzner Cloud token (or use Docker), reuse your GitHub
login, and it connects Claude Code and Codex for you (and ssh to your agents' machines). Every step
can be skipped and changed later.
Nothing bills until an agent opens a VM. The service on your laptop is free and idle until then, and setup puts a monthly cap on VMs (10 EUR unless you choose another).
macOS or Linux, with
gitClaude Code, Codex or T3 Code
For the VMs, one of:
a Hetzner Cloud account (about 0.011 EUR an hour while a VM is open). Make a project just for openajar: its token can delete any server in that project.
Docker running on your computer (free, less isolated)
Optional: the GitHub CLI (
gh), so setup can reuse your login for private repositories
The installer puts uv and openajar in ~/.local/bin, never asks for sudo, and is safe to run
again: it updates openajar in place, and restarts the local service when it runs, so it runs the new
version on the same port. To install a branch or an older release, set OPENAJAR_GIT_REF
(for example OPENAJAR_GIT_REF=v0.5.3).
Coming from agentos 0.3 or 0.4? Run the same install line. It replaces the agentos command with
openajar and keeps your setup, environments and saves where they are.
Then ask your agent
Start a new Claude Code or Codex session and say:
Work in openajar on github.com/you/app: fix the failing checkout test, show me the page working, and open a pull request.
The agent opens its computer, gives you a live view link to watch its screen, and comes back with a screenshot and the pull request link. You can take over at any time.
How it works
Your agent asks for its computer when the task needs one. openajar rents a VM in your own account (Hetzner or Morph) or starts a Docker container, clones your repository into it and starts a browser there.
The agent works on it like on its own laptop. It edits files, runs the tests in its terminal, starts the dev server and opens the page in its browser, where
localhostis the machine. It can open a program on the machine's desktop (an app that is not a web page) and use it with a real pointer and keyboard. It can also use its own shell:ssh openajar-<id>,rsyncandscp. Dev servers keep running when openajar restarts or updates.It signs in when it needs to. On a sign-in page it asks openajar, which types a login you chose from your vault into its browser. The model never sees the password.
It shows you the result: screenshots and videos kept as proof, and a pushed branch with its pull request. Pushes go through openajar, so the machine never holds your key.
It closes when done, and stays. When the task is done the agent closes its computer: the whole machine is saved and the VM deleted, so it costs cents a month (a single-use one is just deleted). The same happens when it goes idle. The next chat that asks for it by its title gets it back: in seconds on Morph, in about a minute on Hetzner.
A machine that dies is noticed. If its container or server stops outside openajar (killed, powered off, deleted), openajar asks the provider, says so in every tool and in the web app, and opening the same title again starts a fresh machine, from its last save when there is one.
The thinking stays on your laptop, in the agent you already use. openajar rents the machines in your account, and bills you nothing of its own.
Keep it and come back
Each computer has a title. Say "continue the checkout fix in openajar" in any new chat, and the
agent gets the same machine back: the branch, the files, node_modules, Docker volumes, the dev
server and the browser's sign-ins, plus the note the last agent left.
Good for | While nobody uses it | |
💾 Saves when idle (the default) | a computer that stays: work that spans days, accounts it stays signed in to | cents a month: the machine is saved and the VM deleted, back in seconds on Morph or about a minute on Hetzner |
🧹 Single use | a quick fix: work, push, done | nothing: the VM is deleted |
⚡ Kept running | a machine that is always on | billed every hour (about 7.80 EUR a month), and only after you allow it |
Setup offers saves when idle first. The agent asks for single use only for a one-off fix, and never keeps one running unless you asked for it.
Signed in, without showing a password
An agent's computer can stay signed in to the accounts it works with: a staging dashboard, an admin page, a test account. It does not post or click for you on a schedule. It opens the account when the work needs it, like you would.
You choose which logins from your vault a computer may use, by its title, its repository or all of them (the password comes from a hidden prompt, never the command line):
openajar environments login add admin.example.com --title "Shop admin" # or --repo me/shop, or --allWhen the agent reaches a sign-in page, it calls the login tool. openajar types the stored login into
that computer's browser, and the model never sees it. If the site signs it out later, the agent signs
in again the same way, without asking you, or you do it from your laptop:
openajar environments login "Shop admin" admin.example.com. Nothing else in your vault reaches the
machine.
What it costs
openajar itself is free and open source. You pay your VM provider directly, with your own account.
Price | |
A VM while it is open (Hetzner | about 0.011 EUR an hour |
A task under an hour, from open to pull request | about 0.01 EUR |
A saved computer (about 4 GB) | about 0.05 EUR a month |
A computer kept running all month | about 7.80 EUR a month |
Docker on your own computer | free |
Setup sets limits that hold whatever an agent asks: 10 EUR a month, 4 hours per VM, 2 VMs at
once. Change them any time with openajar setup limits. The agent sees the cost so far, and so do
you.
Safe by default
🔑 No keys on the machine. No key, token or password reaches the machine unless you bind a login to it, and the model never sees one. Your GitHub and cloud tokens stay on your laptop. A push goes through openajar with a token for that one repository, which dies with the VM.
🔐 Logins you choose. A login you bind is typed into that computer's browser, so its browser holds that session. A computer gets no other login.
🌿 Your branches are safe. The agent pushes new branches. It never deletes or rewrites your default branch, protected branches, tags, or branches someone else pushed.
🧱 Commands only on the VM. The agent's commands run in its environment, never on your laptop.
🔒 One chat per machine. Each machine answers only the chat that opened it, so two agents never work on the same computer by accident.
✍️ Commits are yours. With your GitHub login saved, commits carry your GitHub name and noreply address, so they link to your account without showing your email.
👀 You can always watch. Every environment has a live view of its screen, and you can take over with one click: the agent's tools then stay off the screen. It is still the agent's computer, so sign in there only to accounts the agent is meant to use.
💶 Hard limits. Past the monthly cap, the time limit or the VM count, opening is refused.
🗑️ Nothing left running. An idle computer is saved and its VM deleted after an hour (a single-use one is deleted), and work that was never pushed gets a rescue save instead of being lost.
What this defends against, and what it does not: docs/THREAT-MODEL.md.
Works with
Agent | Setup |
Claude Code | connected by |
Codex | connected by |
T3 Code | nothing more: it uses Claude Code's and Codex's settings, and shows the live view in its preview pane |
Any MCP client (Cursor, Claude Desktop, for example) | add a stdio server that runs |
For a client that starts a command, the server entry is the same everywhere:
{ "mcpServers": { "openajar": { "command": "openajar", "args": ["mcp"] } } }openajar mcp talks to openajar on your computer and starts its service when it is stopped. On a
computer where openajar is not set up yet, it still answers, and tells the agent (and you) what to run.
npx -y openajar does the same through the installed CLI, and says what to install when there is none.
It is also listed in the MCP Registry as
com.openajar/openajar.
The web app
The live view link shows the agent's computer as it is now: its desktop with the browser, a terminal and any app the agent opened, and a violet pointer with the agent's name wherever it clicks, types or scrolls. Press Take over to click and type yourself, and Hand back when you are done. A live view link shows everything on that screen, the agent's commands and their output included, so share it as you would the screen. The round record button saves what you see as a video on your computer, ready to share. It is made in your browser and never uploaded.
openajar has a web app at http://127.0.0.1:7410/. Home says in a sentence or two what your agents
are doing and shows each open computer's screen. Needs you holds what waits for your answer,
Computers lists your agents' environments (open, saved and closed, each with a picture of its
screen) and your own machines, and What happened tells what the agents did, in plain words. For a
business there are Accounts, Jobs that repeat and Brand; Runs and checks and Site APIs
appear for developers once they are used, and Settings is last. Each computer has a page with its
live screen, the proofs, a replay of what its browser did, the commands it ran, its pushed branches,
what it costs and how long it has left. A computer whose machine stopped says so in red, with what to
do. It is open source like the rest (Apache-2.0, in web/).
The one-line install includes the web app, as an option: openajar setup offers it (yes by default)
and downloads the copy built for your version, checked against its release's sha256. Running the
installer again updates it with openajar. To leave it out, answer no, or add it later with
openajar web install (openajar web remove takes it away). Without it, every computer still has
its live view link, and openajar environments list in the terminal.
The live view link works on its own, without the web app.
FAQ
The agent still runs where it runs now. Only its work moves: the commands, the dev server and the browser run on a computer of its own that holds none of your keys, and only the logins you bind to it. So it can work without asking you at every step, several agents can work at once, and your laptop stays free.
The idea is the same: an agent gets a computer of its own, with a browser, a terminal and files, that stays between conversations. The difference is whose agent and whose machine. Those are hosted agents: you use their agent, on computers they run. openajar is for the agent you already use (Claude Code, Codex, T3 Code or any MCP client), on machines in your own account (Hetzner, Morph, or Docker on your computer). Each agent or chat gets a computer of its own, not one shared box. Logins come from your own vault and are typed in without the model seeing them, pushes go through a git gateway so no key sits on the machine, and you set the limits on spend. It is open source, with no openajar account in between.
Those are sandboxes for code your product runs: your code starts one through an SDK, runs something in it and throws it away, so the next run starts from nothing. They fit when you build a product that runs code for your users. openajar is a computer that stays and is signed in, for the agent in your chat: the agent asks for it itself over MCP, and tomorrow it gets the same machine back, with its installs, its branch, its dev server and its browser's sign-ins. You can watch that browser live and take it over.
Your code is: the repository is cloned there, or the agent uploads its local checkout, so it can work on it. A saved computer keeps that code in a snapshot in your own provider account until you forget it. Your keys are not: no key, token or password reaches the machine unless you bind a login to it, and the model never sees one. A login you bind is typed into that computer's browser, so its browser holds that session, and a save keeps it.
Yes, while an agent works. The agent runs on your laptop and reaches its computer through openajar there. When the laptop sleeps, each computer is saved and its VM deleted (unless you keep one running), so nothing bills overnight. A dev server on the VM keeps running while openajar restarts or updates. For machines that keep working while you sleep, run openajar on a server (below).
Yes. With your GitHub login saved in setup, it can clone and push any repository that login can reach. Without one, the agent gives you a link to a page where you paste a token for that repository. The token never goes through the chat, and the agent never sees it.
Hetzner Cloud, Morph Cloud (machines start in about a second, and a saved environment pauses with
its memory, so it comes back in seconds with its dev server still running), and Docker on your own
computer. Each uses your own account. The provider layer (openajar.vms) is small, and more providers
are welcome.
Update: run the install command again, also from agentos 0.3 or 0.4.
Remove: see docs/LOCAL.md (forget the saves you no longer need first, so no snapshot stays in your Hetzner account).
Run it on a server
A server keeps working while your laptop sleeps. It can also keep signed-in browsers for your own
accounts on the server itself, and run studio's page checks (ui_check). A node is a small Linux VPS (Ubuntu 22.04 or
later, or Debian 12). On the node:
git clone https://github.com/sabalys-ramunas/openajar openajar && cd openajar
sudo deploy/install-node.sh --systemd --user agentos --hardened
sudo openajar vm setup # paste the Hetzner token
sudo openajar vm image build dev # the snapshot each VM boots from
sudo openajar environments setup # says what is still missingThen on your computer, with the node in ~/.ssh/config as mynode:
curl -fsSL https://openajar.com/install.sh | sh
openajar connect mynodeInstall, hardening, backups and upgrades: deploy/README.md.
For agents: the tools
The default list is the loop of an agent on its own computer:
Tool | What it does |
| opens a computer (or resumes the one with that title) with the repo in |
| what is open and saved, the cost so far, ports, git, and the pull request link |
| the last call when the task is done: saved with a note for the next agent (a single-use one is deleted) |
| saves the whole machine now |
| one-use links to send a local checkout up, or a file down to you |
| run a command in its terminal; dev servers and long jobs, waiting until a port listens |
| read (several files in one call), write and edit code |
| the agent's own shell on the machine, with |
| its browser, tabs and dialogs: read the page as an outline, act by reference |
| waits while you have taken the browser over |
| a screenshot or a video kept as proof, at desktop or phone width |
| opens the pull request for the pushed branch, with its proofs |
| an undo point before a risky step, and going back to it |
| a link for you to a dev server on the machine |
| signs in on the page with a login you bound to that computer (the model never sees it); waits for your answer to an approval |
| the other groups, loaded when the agent needs them |
The groups: screen (apps on its desktop that are not web pages: a picture of the screen and its
windows, real clicks, keys and typing, starting an app), accounts (driving your own signed-in
account browsers on a server node: list, open, claim, live view, uploads), browser (a browser's
downloads, scrolling a feed),
terminals (terminals and services the node keeps, raw VMs, forgetting saves), studio (checking
a page you build), devtools, control, vault, flows, workflows, mail, memory,
profiles and more.
The other tools load in groups when the agent needs them: docs/TOOLS.md. If a
machine stops, every call that needs it answers machine_gone, and environment_open with the same
title replaces it with a fresh one. The skill that teaches an agent the loop:
openajar-environment.
Status
Alpha, at 0.5.2. 0.5.0 gave the agent's computer a desktop you can watch and work with, and the
new name. 0.5.1 notices a machine that dies and replaces it on the same title, keeps typing in the app
the agent opened, and brings the web app's simpler navigation and its new design to every screen.
0.5.2 names each agent the same way everywhere ("Claude Code"), and an update restarts the running service.
Computers that stay and their logins are new, and the tools may still change between minor versions:
see the changelog and the releases.
On a laptop there is no ui_check yet (it needs a server), and the laptop must be awake while a VM works.
Docs
openajar on your laptop: the service, sleep, costs, where tokens live | |
the agent's computer in depth: setup, keeping, limits, troubleshooting | |
every MCP tool, every error code and its fix | |
how git works through openajar | |
running openajar on a server | |
what it defends against | |
how it is built, and where it is going | |
the dev loop and the tests |
Contributing
Issues and pull requests are welcome. CONTRIBUTING.md has the dev loop: no cloud
account needed (uv run openajar dev up and the unit tests run on a laptop). For a security
problem, see SECURITY.md and report it privately.
License
Tool Schema Changelog
Recent tool additions, removals, and schema changes observed during successful MCP inspections.
Loading tool schema changelog…
This server cannot be deployed
Maintenance
Related MCP Connectors
Persistent cloud workspaces for AI agents: run commands, edit files, use git and a browser.
Cloud desktops for AI agents: create a Linux computer, see its screen, click, type and run tasks.
Persistent Linux computers for AI agents: desktop, signed-in browser, vault, apps and shell.
Your AI dev team: agents that build, test, review and ship, each on its own cloud machine.
Related MCP Servers
- FlicenseNot gradedqualityDmaintenanceProvisions Docker-based development environments on demand, allowing AI agents to create, manage, and inspect containerized dev environments without manual setup.-

instanode-mcpofficial
AlicenseAqualityDmaintenanceEnables AI coding agents to instantly provision ephemeral developer infrastructure like Postgres, Redis, MongoDB, and container deployments over HTTPS, with no Docker or signup required for the free anonymous tier.31MIT
MileHost MCP Serverofficial
AlicenseCqualityCmaintenanceEnables AI coding agents to manage cloud containers, create and edit files, run commands, and deploy projects directly.247MIT- AlicenseAqualityBmaintenanceEnables AI agents to spin up disposable Tenki microVM sandboxes in seconds and use them to run code, manage files, run git commands, and expose preview URLs.71659 npmMIT