Model or dataset
openagents-org/openagents avatar
openagents-org/openagents

OpenAgents installs by piping a remote script into your shell and shares one browser across agents

OpenAgents - The collaboration OS for AI agents

4,405 stars466 forksTypeScriptApache-2.0

At a glance

What is it?
OpenAgents is a workspace layer that puts every coding agent you run behind a single URL, with a launcher CLI and a desktop app to manage them. The readme is unusually candid about support status, marking one agent as a preview pinned to a preview release and three as beta with a note on exactly which tests have not run. The security surface is the interesting part: a shared visible browser, one-command public tunnels, and credentials set per agent type.
Who is it for?
OpenAgents is a reasonable fit if the problem is that your agents are scattered across terminals and machines and you want one place to see and direct them, since the workspace address, the shared files and the mention mechanism address exactly that. Three things to weigh.
Can I use it commercially?
Yes. Apache-2.0 is a permissive licence: you can use, modify and sell software built on it, as long as you keep its copyright and licence notices.
Is it still maintained?
Yes. The repository received new commits within the last day.
What is it written in?
Mainly TypeScript, according to GitHub's language statistics.

Answers come from the project's GitHub data, last synced on November 15, 2026, and from our analysis. They are not legal advice.

From daily snapshots

Star history

  • openagents-org/openagents4,405 ★ · +337
Star history
Repository2026-09-102026-11-15
openagents-org/openagents4.1k4.4k

337 Stars in the last 66 days, measured from the daily GitHub snapshot. Compare with other projects

Editorial analysis

Installation pipes a remote script straight into your shell

The quickest route to the launcher is also the one with the least ceremony. On macOS and Linux it is a single line that downloads a script and hands it to the shell:

bash
# macOS / Linux
curl -fsSL https://openagents.org/install.sh | bash

# Windows (PowerShell)
irm https://openagents.org/install.ps1 | iex

There is no checksum, no pinned version and no prompt in the documented flow, so what runs is whatever the server returns at that moment. The alternative is to download the launcher as a desktop application for macOS, Windows or Linux as an AppImage, or to pick a specific build from the releases page, where the recent tags are all launcher-scoped: launcher-v1.1.9 on 2026-11-01, launcher-v1.1.10 on 2026-11-02 and launcher-v1.1.11 on 2026-11-03.

The project publishes both a Python package on PyPI and a launcher package on npm under the `@openagents-org` scope, so the two halves of the tooling are distributed through different channels with different version schemes.

agn create writes config only, and the readme says so after the fact

The launcher's command surface is five verbs:

bash
agn create <name> --type <type> --install   # create agent and install a runtime
agn connect <name> <workspace-token>        # connect agent into workspace
agn env <type> --set LLM_API_KEY=sk-...     # set credentials
agn up                                      # start the daemon
agn                                         # open the dashboard

The footgun is documented immediately below that block. `agn create` only writes the agent configuration, so an agent created without the install flag will have a config and no runtime behind it. The fix is either to run `agn install <type>` first or to pass the flag during creation so the runtime is installed in the same step.

Two more things follow from the shape of these commands. Agents run as a background daemon once `agn up` has been issued, which means the launcher is a supervisor rather than a foreground process, and the workspace token is passed on the command line when connecting, so it will appear in shell history and in the process list of anything reading it.

A browser everyone can see, and tunnels that publish a dev server

The features that make the workspace feel like one place are also the ones that widen the blast radius. The shared browser lets agents open pages, click elements, take screenshots and fill forms in a browser that everyone in the workspace can see, so an agent's actions are visible to the other participants but also to any human with access to the workspace.

Tunnels are the second one. A local development server can be exposed as a public URL with one command, which is the fastest way to look at what an agent built from a phone. It is also a way to publish a server that was only ever meant to listen on localhost.

Files work the same way: agents upload code, documents and reports to the workspace, and any agent or human in it can read, edit or download them. Combined with the persistent address pattern, a workspace looks like a shared drive with a browser attached, which is exactly the convenience and exactly the exposure.

The support table marks one agent preview and three beta

The supported agents table is the most useful part of the readme because it grades itself. Nine are listed as supported: OpenClaw, Claude Code, Codex CLI, Hermes Agent, Cursor, OpenCode, GitHub Copilot CLI, Gemini CLI and Amp, with a one-line description of what each one is.

Four are not. Cline is marked supported but beta. Aider is beta, and the note under the table explains exactly what that means: the full offline test suite covering provider resolution, sessions, Git safety and install detection passes, but a real end-to-end run against a live model provider has not been completed, and the create and connect flow is available so a reader can run that verification themselves. Goose is beta as well. DeepSeek Harness is the only preview, described as headless mode and pinned to a preview release.

Two of the supported entries carry their own guide files in the documentation directory, GitHub Copilot CLI and Cline, and DeepSeek has one too, so the thinner entries are the ones whose behaviour you will have to read rather than infer.

Aider gets one key for many providers because it routes through LiteLLM

The per-agent configuration is the other half of the launcher, and Aider is the clearest example because it is multi-provider. It runs in a non-interactive scripting mode, invoked with a message file, and the adapter keeps a separate chat history per workspace channel so follow-up context survives, while writing any file changes into the agent's configured working directory.

Because it routes through LiteLLM, you choose a provider and a model and supply one key:

bash
agn install aider                                  # install the Aider CLI (aider.chat)
agn env aider --set AIDER_PROVIDER=anthropic       # which provider the key is for
agn env aider --set AIDER_MODEL=sonnet             # a model for that provider
agn env aider --set LLM_API_KEY=<your-key>         # one key, injected per provider
agn create my-aider --type aider --path ~/code     # create an instance + working dir
agn up

So the credential story is per agent type rather than global, which is the right shape when different agents bill different providers, and it means the key lives wherever the launcher stores environment values for that type. The working directory is set at creation time with a path flag, which is how the adapter knows where to put file changes.

The Python package calls itself a protocol framework; the readme calls it an OS

Two descriptions of the same project sit side by side. The readme calls it a collaborative operating system for agents, a workspace where everything runs and nothing needs an account. The Python packaging metadata calls it a flexible framework for building multi-agent systems with customizable protocols, which is a different product: a library for building agents rather than a place to run them.

The metadata also shows how young this is. The version is `0.9.3.post20`, a post-release suffix on 0.9.3, the classifier is Alpha, and the supported Python range starts at 3.8 with classifiers up to 3.12. The dependencies are a conventional agent stack: pydantic for models, aiohttp and websockets for async transport, an asyncio throttle, click, rich, typer and textual for the command line and terminal interface, and python-dotenv for configuration. An optional extra adds gRPC, its code generator and cryptography for an SDK with an MCP server.

The default branch is `develop`, not `main`, which is worth knowing before you pin anything.

setup.py copies a prebuilt JavaScript studio into the package, or tells you to install Node

The Python setup script describes itself as minimal and deferring to the manifest, but it does one thing before handing over. A function looks for a built studio directory under the SDK path and, if it exists, removes any previous copy and copies the new one into the package tree before setup runs.

When that directory is missing, the script prints a warning and explains the consequence: the package will still work, but users will need Node.js to run the studio, and to get the built frontend they should run the npm build in the studio directory first. So the Python distribution is a wheel that may or may not contain compiled web assets, decided by whether a build ran before packaging, and the failure mode is discovered by the person installing it.

The rest of the tree tells you where the product lives: a `packages/` directory, `sdk/` holding the Python package source, a `workspace/` directory, a `registry/`, `cloud_providers/`, `scripts/`, `docs/` with its own build configuration, a `tests/` tree, and both `llms.txt` and a `marketing/` directory at the root. There are two changelogs as well, a file and a directory.

Editorial conclusion

OpenAgents is a reasonable fit if the problem is that your agents are scattered across terminals and machines and you want one place to see and direct them, since the workspace address, the shared files and the mention mechanism address exactly that. Three things to weigh. The documented install executes a remote script directly into your shell, so read it before running it or download the desktop launcher instead. The shared browser is visible to everyone in the workspace and tunnels publish a local dev server to a public URL, so decide what belongs in a workspace before connecting an agent that holds credentials. And support is uneven by the project's own table, with one agent in preview and three in beta, so check the status of the specific agent you plan to depend on.

Frequently asked questions

What is OpenAgents?

OpenAgents is an open-source workspace layer for AI agents, described as a collaboration operating system for agents. One workspace URL is where every connected agent appears, and the agents in it share the same threads, files and browser. It is Apache 2.0 licensed, requires no account, and is managed through a launcher CLI named `agn` plus a desktop application.

Which coding agents does OpenAgents support?

Nine are listed as supported: OpenClaw, Claude Code, Codex CLI, Hermes Agent, Cursor, OpenCode, GitHub Copilot CLI, Gemini CLI and Amp. Cline is supported but in beta, Aider and Goose are beta, and DeepSeek Harness is in preview, pinned to a preview release. The Aider note says its offline test suite passes while a live provider run has not been completed.

How do I install the OpenAgents launcher?

On macOS and Linux the documented command is `curl -fsSL https://openagents.org/install.sh | bash`, and on Windows PowerShell it is `irm https://openagents.org/install.ps1 | iex`. Both execute a remote script directly. The alternative is to download the launcher application for macOS, Windows or Linux as an AppImage, or pick a build from the releases page, where recent tags are launcher versions v1.1.9 through v1.1.11.

What do the agn commands do?

`agn create` writes an agent configuration and, with the `--install` flag, installs its runtime as well; `agn connect` joins an agent to a workspace using a workspace token; `agn env` sets credentials such as an API key for a given agent type; `agn up` starts the background daemon; and `agn` on its own opens the interactive dashboard.

How does OpenAgents handle API keys for different agents?

Credentials are set per agent type with `agn env <type> --set`, so each agent holds its own key rather than sharing one global credential. For Aider, which routes through LiteLLM, you set a provider and a model alongside a single key, and the launcher injects that one key for the provider you named.

Is OpenAgents open source?

Yes, everything is under Apache 2.0 with no vendor lock-in and no mandatory accounts. The Python package is published on PyPI as openagents at version 0.9.3.post20, and the launcher is published on npm under the `@openagents-org` scope as `@openagents-org/agent-launcher`.

Official sources

  1. License: Apache-2.0
  2. openagents-org/openagents on GitHub
  3. Project website
  4. README
  5. Releases
Add this badge to your README

If you maintain this project, the badge below links readers to this analysis and shows its maintenance status from the daily GitHub snapshot. Paste the markdown into your README; add ?metric=license or ?metric=stars to the image URL for a different field.

Add this badge to your README

markdown
[![Hysen Labs](https://hysenlabs.com/badge/openagents-org-openagents.svg)](https://hysenlabs.com/projects/openagents-org-openagents)

Star history chart for your README

markdown
[![Star history](https://hysenlabs.com/chart/openagents-org-openagents.svg)](https://hysenlabs.com/projects/openagents-org-openagents)

Was this useful?