Skip to main content
Glama

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>, rsync and scp, 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 | sh

Setup 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.

TIP

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 git

  • Claude 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

  1. 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.

  2. 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 localhost is 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>, rsync and scp. Dev servers keep running when openajar restarts or updates.

  3. 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.

  4. 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.

  5. 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.

  6. 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 --all

When 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 cx23: 2 CPU, 4 GB)

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 openajar setup, with the openajar skills

Codex

connected by openajar setup

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 openajar mcp (or npx -y openajar, or uvx openajar mcp); or by hand: Streamable HTTP at http://127.0.0.1:7410/mcp, with the token setup keeps for your agents

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 missing

Then on your computer, with the node in ~/.ssh/config as mynode:

curl -fsSL https://openajar.com/install.sh | sh
openajar connect mynode

Install, 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

environment_open(title, repo, keep)

opens a computer (or resumes the one with that title) with the repo in /work/<name> and a browser; it saves when idle unless keep="none"; returns on, which every later call carries

environment()

what is open and saved, the cost so far, ports, git, and the pull request link

environment_close(note)

the last call when the task is done: saved with a note for the next agent (a single-use one is deleted)

environment_save(note)

saves the whole machine now

environment_upload(), environment_download(path)

one-use links to send a local checkout up, or a file down to you

terminal_exec, terminal_job_start, terminal_job_read(until_port=3000), terminal_job_cancel

run a command in its terminal; dev servers and long jobs, waiting until a port listens

file_read, file_write, file_edit

read (several files in one call), write and edit code

ssh openajar-<id> (local mode)

the agent's own shell on the machine, with scp and rsync

browser_navigate, browser_snapshot, browser_act, browser_wait, browser_tabs, browser_dialog

its browser, tabs and dialogs: read the page as an outline, act by reference

browser_wait_handback

waits while you have taken the browser over

browser_screenshot(proof=...), browser_record

a screenshot or a video kept as proof, at desktop or phone width

environment_pull_request(title)

opens the pull request for the pushed branch, with its proofs

environment_checkpoint(note), environment_rollback

an undo point before a risky step, and going back to it

environment_port(port)

a link for you to a dev server on the machine

login, approval_wait

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

tools_more, tools_call

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

NOTE

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

docs/LOCAL.md

openajar on your laptop: the service, sleep, costs, where tokens live

docs/ENVIRONMENTS.md

the agent's computer in depth: setup, keeping, limits, troubleshooting

docs/TOOLS.md, docs/ERRORS.md

every MCP tool, every error code and its fix

docs/GIT.md

how git works through openajar

deploy/README.md

running openajar on a server

docs/THREAT-MODEL.md

what it defends against

docs/ARCHITECTURE.md, docs/VISION.md

how it is built, and where it is going

docs/DEVELOPING.md

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

Apache License 2.0: see LICENSE and NOTICE.

Tool Schema Changelog

Recent tool additions, removals, and schema changes observed during successful MCP inspections.

Loading tool schema changelog…

    Related MCP Connectors

    Related MCP Servers

    • F
      license
      Not graded
      quality
      D
      maintenance
      Provisions Docker-based development environments on demand, allowing AI agents to create, manage, and inspect containerized dev environments without manual setup.
      -
    • A
      license
      A
      quality
      D
      maintenance
      Enables 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.
      31
      MIT