Rainbow Bridge
한국어GitHub

In alpha, for macOS 14 and later

Remote desktop, built for humans and AI agents.

Control another computer yourself, or hand the work to an agent such as Claude or Codex. Where the operating system allows, the agent works in the background with a cursor of its own, and the owner keeps their pointer and keeps working.

Open source under Apache-2.0. Yours to host. No account with us is required.

  • The agent has a cursor of its own

    A line in its color goes around the window it works in, with a tab that names it and says what it just did.

  • Your pointer stays yours

    In the background, your pointer does not move and your window keeps the keyboard.

  • Stop is one step away

    The menu bar’s menu says who is in, where, and for how much longer. Stop ends it at once.

One desktop, two kinds of operator

A person and an agent are both first-class here. They share one kind of session, one way of asking, and one way of being stopped.

  • You, at the keys

    See the whole screen and work across every app with your own mouse and keyboard, as with any remote desktop.

  • Your agent, through MCP

    An agent observes the screen, acts on it, and confirms the result through MCP tools. It runs on your side. Nothing of Claude or Codex is installed on the computer it works on.

The four modes, in the words the owner reads before allowing one.
ModeWhoWhat the owner is told
View onlyA personViewing only. They cannot control this Mac.
ControlA personUses your pointer and keyboard
In the backgroundAn agentIn the background. Your pointer and keyboard stay yours.
With your pointerAn agentWith your pointer and keyboard. It can interrupt what you are doing.

An agent that works beside you, not in your place

A remote desktop usually takes the pointer. An agent in the background here has a cursor of its own: it clicks and types in its window while you keep typing in yours.

Background input depends on the app. When a step cannot be done in the background, the agent stops and says why. It is never moved to your pointer by itself: taking over is a new question, and you can say no.

  • In its window
  • Acting: the click was sent
  • Paused
  • Needs you
The agent’s cursor, as it is drawn on the desktop.
  • A color for each agent

    The first agent is pink, the second green, the third blue: the logo’s own colors. Its cursor and the line around its window are that color.

  • It says what it just did

    For two seconds after each action, the tab on its window says it in one word: Clicking, Typing, Scrolling.

  • Your hand comes first

    While someone does hold your pointer, moving the mouse or typing pauses every session at once.

Nothing is shown until the owner allows it

Rainbow Bridge asks someone to let a person or an agent use their computer. So every screen answers one question: does the owner understand what they are allowing, and know how to stop it?

The question. Refusing is where the keyboard starts.
The menu bar’s menu while an agent works.
  • One question, three answers

    Every request says who is asking, what for, and in which mode. The answers are Don’t allow, Always allow, and Allow once. The keyboard starts on Don’t allow, and Return allows nothing.

  • Limited in mode and in time

    A session is allowed in one mode, for 15 minutes, 30 minutes, or an hour. When its time runs out, it ends.

  • Always visible

    While anyone is in, the logo in the menu bar moves. Its menu says who, in which app, in which mode, and for how much longer.

  • Stop in one step

    Stop is in the menu bar’s menu, and Control-Option-Command-Escape ends every session from any app. Stopping never depends on the pointer, because someone else may be holding it.

  • The pointer is asked for every time

    Always allowing an agent covers its work in the background only. Each time it wants your pointer and keyboard, you are asked again.

  • Checked on the owner’s computer

    An agent may follow instructions it reads on the screen. So everything it asks to see or do is checked on the owner’s computer against what was allowed. A prompt is not the boundary.

Two jobs, each a few steps

Let an agent use this Mac

  1. Connect an agent

    In the window, choose Claude Code or Codex. There is no terminal and nothing to set up.

  2. The agent asks

    The first tool it uses brings the question to your screen.

  3. Allow it, and keep working

    It works in the background. Activity lists what it did, each marked sent, confirmed, or failed.

This Mac, while an agent works on it.

Use another computer

  1. Its owner shares it

    Share this Mac shows six digits. They work once, for ten minutes.

  2. Type the code, or say it to your agent

    Add a computer takes the code. Or tell your agent: “Connect to 482 915 and set up the printer.”

  3. Its owner allows

    Only then is the screen shown. Its owner can pause or stop the session at any time.

Share this Mac. One code, read out or typed.

Tools to observe, act, and confirm

Rainbow Bridge’s MCP server gives an agent the desktop a person would see, as tools. It follows the Model Context Protocol, so any client that speaks it can use it.

  • Sent is not confirmed

    Sending a click and confirming its result are different states. Every action comes back as sent, confirmed, or failed, so neither the agent nor you takes one for another.

  • An element, not a guess

    An agent can press a button by the name the window gave it, with no coordinates and no pointer.

  • Refusals it can pass on

    When the owner refuses, pauses, or stops, the server says so in a sentence the agent can repeat to you.

  • Claude Code, Codex, or another

    It has been run with Claude Code and Codex. Any other MCP client adds the server with one line.

The tools, by what they are for.
GroupTools
Connection
  • list_computers
  • get_computer
  • request_session
  • get_session
  • close_session
Observation
  • list_displays
  • list_applications
  • list_windows
  • capture_screen
  • capture_window
  • get_ui_tree
Action
  • click
  • click_element
  • move_pointer
  • scroll
  • type_text
  • press_key
  • hotkey
  • drag
  • launch_application
  • activate_window
Session control
  • request_control_mode
  • get_action_result
  • wait_for_state
  • release_control
Telling your agent another computer’s code.
Activity, on the computer it happened on.

Yours to run

The applications, the protocol, the Broker, and the agent server are open source under Apache-2.0. The core works without an account with us, without our servers, and without anyone else’s.

  • No account

    Nothing you do between your own computers needs an account.

  • Host it yourself

    Run your own Broker for codes, and your own relay for two computers that cannot reach each other directly. Container images and a Compose file are in the repository.

  • Servers that cannot read your screen

    Screen and input travel encrypted between the two computers. A Broker or a relay, ours or yours, passes on what it cannot read.

  • Nothing stored by default

    No screen video, no screenshots, and no telemetry you did not agree to.

Build it from source

You need macOS, Rust 1.97, and Go 1.27. On the Mac to be operated:

cargo xtask tailcat
cargo build --release
target/release/rainbow-bridge-host --invitation-file invitation.txt

Send invitation.txt to the other Mac. It is a secret for the hour it can be used. There:

target/release/rainbow-bridge --connect-file invitation.txt

The first Mac asks its owner in a window before anything is shown.

Where it is today

Rainbow Bridge is in alpha and runs on macOS only. This is what has been built and run, and what has not.

Built and run

  • A Mac shared after its owner allows, viewed and controlled from another Mac
  • An agent operating a Mac through MCP, in the background where the app allows
  • Six-digit codes, and computers that are always allowed
  • A Broker and a relay you can run yourself

Not yet

  • A signed installer. Today it is built from source
  • Windows and Linux
  • Clipboard, file transfer, audio, and more than one display
  • Access while nobody is there to allow it

What people ask first

How is this different from another remote desktop?

A remote desktop is made for a person at the keys. Rainbow Bridge gives an agent the same standing: it asks the owner in the same way, works through tools made for it, and where the app allows, works in the background without taking the owner’s pointer.

Will an agent move my mouse?

Not in the background. There it has a cursor of its own, and your pointer and keyboard stay yours.

Some steps cannot be done in the background in some apps. Those fail with the reason, and the agent waits. It uses your pointer only after you allow that, and it asks each time.

Is it safe to let an agent use my computer?

Rainbow Bridge does not trust the agent. Everything it asks for is checked on your computer against what you allowed, you see it working, and you can stop it at once.

It does not wall the agent off from your account, though. An agent allowed the whole desktop can reach what you can reach there. And what it reads goes to the provider of its AI model; the question says so before you allow.

Which agents can use it?

Any agent whose application speaks MCP. It has been run with Claude Code and Codex. The agent runs on the side that asks, so nothing of it is installed on the computer it works on.

Do I need an account, or your servers?

No. Two computers can connect with an invitation passed by hand. A Broker puts a six-digit code in its place, and a relay carries a connection that cannot go direct. You can run both yourself.

What can a server in the middle see?

A Broker passes on an invitation and never learns the whole code. A relay forwards encrypted packets it cannot read.

One service, still being built, is different: a hosted agent server, for agents that cannot start a program on your Mac. What such an agent sees passes through that server’s memory on its way to the AI provider. It keeps none of it, the owner is told before allowing, and anyone can run that service themselves.

Is anything recorded?

Screen video and screenshots are not kept. Activity keeps what kind of thing each session did, in which app, and whether it worked. What was typed is never kept.

Which platforms does it run on?

macOS 14 and later, on both sides. Windows and Linux are planned and not started.

What does it cost?

Nothing. It is open source under Apache-2.0, and you can run every part of it yourself.

Read the code. Run it yourself.

Rainbow Bridge is working toward a public alpha on macOS.