Skip to content
oar-shPublic

About

Row your coding agents from anywhere — self-hosted web relay that drives Copilot, Claude, Cursor, Grok, and OpenAI from any browser: phone, tablet, or a second computer.

Topics

Resources

Security policy

Stars

7 stars

Watchers

1 watching

Forks

Repository files navigation

The OAR logo: an otter standing upright

OAR — Open Agent Relay

Drive the coding agents on your machine from any browser (phone, tablet, or a second computer) through a web relay you host yourself.

curl -fsSL oar.sh/install | sh

On Windows, run irm oar.sh/install.ps1 | iex in PowerShell. Other ways to install are under Install. Landing page: oar.sh; the complete guide: oar.sh/docs.

What OAR does

Coding agents such as GitHub Copilot, Claude Code, Cursor, Grok and DeepSeek usually live in a terminal. OAR puts them into a chat you can open anywhere: start a task at your desk, follow it from the sofa, answer the agent's question from your phone. The agents keep running on your own computer, with your files and your logins; OAR passes the conversation back and forth.

flowchart LR
  subgraph devices["Your devices"]
    phone["📱 Phone"]
    browser["💻 Browser"]
  end
  subgraph host["Your computer"]
    relay["OAR relay<br/>chats, queue, history, files"]
    agents["Copilot · OpenAI · Claude · Claude API<br/>Cursor · Grok · DeepSeek"]
  end
  cloud["☁️ Claude Cloud<br/>sandbox at Anthropic"]
  phone <--> relay
  browser <--> relay
  relay <--> agents
  relay <--> cloud
Loading
  • Eight runtimes, one chat: you pick the agent per conversation, and all of them share the same chat, queue, history, file browser, and question cards (Runtimes).
  • Yours: the relay runs on your hardware, answers only on this machine until you change that, and collects no telemetry (Security notes).
  • Under active development: expect occasional rough edges, and some provider SDK features that are missing or incomplete.

In action

OAR on a phone: a finished agent turn in a conversation, with the composer below
On a phone: the same conversations, installable as an app.
Background subagents running in parallel in the task panel, each with live token counts, elapsed time, and its own Stop button
Agents working in parallel, each with live token counts and its own Stop.
A question card in the middle of a turn: the agent offers several choices and a free-text reply
When the agent needs a decision, it asks, and waits for your answer.
An expanded Thoughts block showing the agent's reasoning above its reply
Read the reasoning, not just the answer.
A session watching two other sessions: a finished reply arrives as a compact relay-event row, the watching 2 sessions list is open with Unsubscribe, and a request to also watch a session on a paired relay waits on an Allow / Deny card
Agents that watch agents: woken by events, approving nothing.

Install

  1. Install. Run curl -fsSL oar.sh/install | sh (macOS, Linux) or irm oar.sh/install.ps1 | iex (Windows PowerShell). On macOS and Linux the installer says what it is about to do and asks once, then installs OAR into your home directory, writes a config, makes a relay token (shown once, with a sign-in link: keep it in your password manager), starts the relay, and prints its address with a QR code. On Windows, run oar start afterwards.
  2. Open the address it printed; oar url prints it again. On the relay's own machine that is http://localhost:3333/. For your phone, switch on LAN access with oar setup --lan, or use a tunnel; then sign the phone in with ⚙️ Settings → Security → Sign in another device, or oar url --sign-in on the relay host, a link and QR code that work once.
  3. Turn on an agent under ⚙️ Settings → Providers, then start a conversation with + New Chat.

You need Node.js 22.13 or newer (the macOS and Linux installer brings its own when yours is missing or older) and an account with the agent you want to use; see Prerequisites. There are also installs with npm and from a git checkout.

oar alone opens a menu. oar start, stop, restart and status control the relay, oar service install starts it at boot or sign-in and keeps it running (a systemd user service on Linux, also for a git checkout; the sign-in autostart on Windows), oar doctor shows what it uses, and oar update installs a new release (as does ⚙️ Settings → General → Check for updates). All the details are in Installing and running OAR: the oar command, where OAR keeps its files, and updating.

Runtimes

The runtime (the provider in the UI) is chosen in New Chat and stays fixed for that conversation: switching a provider off, or removing its key, moves no conversation to another one.

Runtime What it is What you need
GitHub Copilot GitHub's coding agent, with every model your Copilot plan offers; it can be switched off, and a new relay turns it on when the Copilot CLI is installed and has run once The Copilot CLI, signed in on the relay host
OpenAI (BYOK) Copilot's agent against OpenAI or a compatible endpoint Your own API key
OpenAI Image A chat whose replies are images, with a daily spending cap; agents can use it too The same key
Claude Claude Code on your machine A Claude login, made from ⚙️ Settings
Claude API Claude Code on your machine, billed to a Claude Console API key; a Claude chat can switch between the two A Claude Console API key
Claude Cloud (experimental) Claude Code in a sandbox at Anthropic, on a GitHub repository A claude.ai account with GitHub connected
Cursor Cursor's agent A Cursor API key
Grok xAI's Grok CLI A Grok sign-in, made from ⚙️ Settings
DeepSeek Claude Code on your machine, thinking with DeepSeek's models A DeepSeek API key

API keys are entered in ⚙️ Settings and stay on the relay host. The Copilot, Claude and Grok CLIs can be installed and updated from the browser, and Claude and Grok signed in to there too, so for them no shell on the host is needed; Copilot still wants one copilot login in a terminal. Each runtime discovers its own models. The full picture of each runtime is in Providers.

What you can do

A running Claude turn with a message steered into it mid-turn, the reply streaming with its tool calls, and the Steer button in the composer
Send a message while the agent works, and it steers the running turn.
The GitHub Copilot card in Check Usage: AI credits used of the month's allowance, unlimited chat and completions, and what the last turn used
What each plan has left, in one place.
  • Watch a turn live: the reply, the agent's thoughts and every tool call appear as they happen, and each sub-agent gets a bubble of its own. Stop is always one tap away (While a turn runs).
  • Steer or queue: a message sent during a turn goes into it (Claude, Copilot) or waits behind it (While a turn runs).
  • Answer questions: the agent asks on a card with one-click choices, checkmarks or free text, and waits for you; the Inbox gathers the open questions of this relay and the paired ones, by relay and session group, with filters and folds (Question cards, the Inbox).
  • Background work: a task panel lists the commands and sub-agents that outlive a reply, each with its own Stop and its full record, and a chat's worker log opens from its menu; a command's console shows its output live, says when it has gone quiet and counts a test run's passes and failures; the panel and its consoles come back after a relay restart, and a queued restart shows what it waits for and asks after a maximum wait (Background tasks, After a relay restart, worker log).
  • Choose how the agent works: ask, plan, agent or autopilot, plus model and reasoning effort, per message, from the composer's ⚙ (The composer, Relay modes).
  • Files and git: browse the workspace, preview files, review git changes in a diff viewer, and publish a dev server as a preview link (Files, git, and previews, preview servers).
  • Media: the pictures and videos of a session, or of every session, in one gallery, with a file viewer that moves through all of them (Media).
  • Usage and context: plan limits and credits of every provider, the estimated spend of DeepSeek and Claude API keys and of OpenAI images, daily charts by model over the last 7, 30 or 90 days, and what fills the model's context window (Usage and context).
  • Your conversations everywhere: the history lives on the relay, drafts follow you from device to device, and conversations can be searched, archived (which cancels what was still queued for them), grouped and pinned, and 🔥 narrows the list to the sessions active in a window you choose (The conversation list, drafts, session groups, pins).
  • Share a conversation as a read-only link, hide single messages and the host's paths from it, and see when it was opened (Sharing).
  • On your phone: install OAR as an app and get push notifications, sent by the relay itself with nothing to set up; back walks through the conversations you opened, a pinch zooms the whole app, and held sideways it keeps a phone's layout (Notifications and the app, back and forward, zoom, a phone held sideways).

The full tour is in Using the web UI; every setting and config key is in Settings and configuration. What changed in each release is in the changelog, with 0.9.32 as the latest.

Remote access

Out of the box the relay answers only on its own machine. There are three ways to reach it from elsewhere:

  • Same network: oar setup --lan opens the relay to your LAN and prints a QR code for your phone.
  • Cloudflare Tunnel: no server of your own and no open port. You need a Cloudflare account and cloudflared on the relay host (how).
  • SSH tunnel: through a server you already run, behind your own HTTPS proxy (how).
flowchart LR
  phone["📱 Phone"]
  subgraph host["Your computer"]
    relay["OAR relay"]
    cfd["cloudflared"]
  end
  cf["Cloudflare"]
  vps["Your server<br/>HTTPS proxy"]
  phone -- "same network<br/>oar setup --lan" --> relay
  phone -- HTTPS --> cf --> cfd --> relay
  phone -- HTTPS --> vps -- "SSH tunnel" --> relay
Loading

The relay keeps both tunnels running and reconnects them by itself. Beyond your own network, always go through HTTPS. Behind a reverse proxy of your own on another host, tell the relay to trust it (how). The details are in Remote access.

Agents working together

  • Paired relays: connect the OAR on your workstation with the OAR on a server. An agent on one can then read, prompt and start sessions on the other, once you mention that relay with @.
  • Agent sessions: an agent hands parts of its task to new sessions on its own relay, waits for them and reads their results. It is off until you switch it on, the first session asks for your approval, and at most 4 run at once.
  • Watching sessions: an agent subscribes to other sessions and is woken when a question waits, an error happens, or a reply arrives, instead of polling; if it asks, also when the relay runs again after a restart.
  • Late replies: a reply to a prompt the agent stopped waiting for still reaches its conversation, as a relay event, when the other session's turn ends.
flowchart LR
  you(("You")) --> A
  subgraph r1["Relay on your workstation"]
    A["Your agent's session"] -- "starts, waits for" --> B["A session it started"]
  end
  subgraph r2["Paired relay on a server"]
    C["A session there"]
  end
  A -- "reads, prompts, waits" --> C
  C -. "question, reply, error" .-> A
Loading

You stay in charge: per paired relay you decide whether agents may only read, also prompt, or do everything, and in the ask and plan modes every write asks you first. A subscription only notifies; it approves nothing. The loop guard asks you once an agent has sent 30 prompts to other agents without a message from you; Settings → Relays → Agent sessions → Loop guard changes the number, and a card's Allow for this session stops asking for that session until you revoke it.

A session watching two sessions on a paired relay: a reply arrives as a relay-event row, and after a short outage the events the other relay kept arrive as one replayed row

How pairing, permissions and limits work is in Agents working together.

Security notes

  • The relay token is the key to everything. Whoever holds it, or a URL carrying ?token=, can have your agents run commands on the host. Keep it in your password manager: the relay stores only its hash and shows a new one once. oar setup --new-token replaces it. Agents get tokens of their own (OAR_AGENT_TOKEN) that cannot answer your question cards, change settings or pairings; browsers hold a session of their own with a proof key, and paired relays sign in with keys of their own (see Security notes).
  • Sensitive files ask you. A Claude session's edit to a file such as .bashrc or one under .git/ waits for your Allow once on a Safety check card, in every mode.
  • OAR adds reach, not a sandbox. Agents act with the permissions of the user the relay runs as.
  • Local by default. The relay answers only on its own machine until you change that. Beyond your network, use one of the tunnels.
  • Public links are public. Anyone with a shared-conversation or preview link can open it without signing in.
  • No telemetry. The only request to oar.sh is the update check, and it is off until you turn it on.

How keys, cookies, served files, paired relays and Claude Cloud's use of the Claude login are handled: Security notes.

Troubleshooting

Symptom What to do
A runtime is missing from New Chat Turn it on in ⚙️ Settings → Providers. A new relay starts with Copilot on only when the Copilot CLI is installed and has run once, and every other runtime off
A reply says a CLI is missing or signed out Press the button on the failed reply (Install Grok CLI, Sign in to Grok, Claude settings)
Banner says CLI is offline Normal on an idle relay: send a message, and the banner clears once the conversation's worker connects
A conversation seems wedged A Claude turn that has been silent for 10 minutes (30 while a tool runs) ends by itself and the next message starts Claude Code again. Otherwise ☠️ Kill session in the ︙ menu, then retry or send a new message
npm install -g @oar-sh/oar fails with EACCES Do not use sudo; run the installer, which installs into your home directory

oar doctor prints the version, paths, port and provider CLIs in use. More symptoms are in Troubleshooting.

Documentation

Guide What is in it
Installing and running OAR Prerequisites, every install method, starting the relay, the oar command, files, updating
Providers Each runtime in detail, installing provider CLIs from the relay, models
Using the web UI Conversations, the composer, running turns, question cards, background tasks, files, usage, sharing, zoom and navigation, the menu
Settings and configuration Settings, config.json, environment variables, stuck-turn detection
Remote access SSH and Cloudflare tunnels, a reverse proxy on another host, the session-worker path guard
Agents working together Paired relays, agent sessions, watching sessions
Security notes · Troubleshooting The full lists
Preview servers · Copilot CLI with your own key Publishing dev servers; BYOK notes
DEVELOPING.md · server/README.md · CHANGELOG.md Development, tests, relay internals and the repository layout; the HTTP API; release notes

The most complete guide, in six languages, is oar.sh/docs.

Authors

materia79 · d2x

About

Row your coding agents from anywhere — self-hosted web relay that drives Copilot, Claude, Cursor, Grok, and OpenAI from any browser: phone, tablet, or a second computer.

Topics

Resources

Security policy

Stars

7 stars

Watchers

1 watching

Forks

Releases

Packages

Used by

Contributors

Languages