Agentic control

Give your agent real hands.

Rebind ships an MCP server that turns the machine it runs on into a computer-use toolkit for Claude Code, Codex, Cursor, or any MCP client. The agent sees the screen and acts on it, and with Rebind Link its clicks and keystrokes come from a physical USB device, not from software-injected events.

Install MCP server View docs

fig. real hands

How it works

A tool call becomes an input.

The MCP server speaks stdio to the agent on one side and the Rebind remote relay on the other. The agent works the same see, decide, act loop you do, over the same input path your hardware uses.

perception

The agent sees the screen

Full-display screenshots with the cursor marked, single-window captures, and native-resolution zoom for small text. Every coordinate the agent emits is a pixel in the picture it just saw.

action

The agent moves real hardware

Clicks, typing, key combos, and scrolling arrive as real HID input, not synthetic OS events. What works for your hands works for the agent, in any application on the machine.

verification

The agent checks its work

After every action the agent can re-capture the screen, zoom into the result at native resolution, and read the cursor back. It confirms the click landed instead of assuming it did.

Field demo

The loop, run for real.

One session, start to finish: an agent on Claude Haiku is told to open Safari, find three AI stories on Hacker News, and return them as JSON — using Rebind tools only. No browser framework, no scraping API. It works the screen the way you would.

OpenCode terminal with the prompt: using Rebind tools only, open Safari, navigate to news.ycombinator.com, and return the first 3 AI results in JSON format

01 · the task

A prompt, in plain English

An OpenCode session with the Rebind MCP server attached. The whole instruction: using Rebind tools only, open Safari, go to Hacker News, and return the first three AI stories as JSON.

The agent's reasoning: a six-step plan using rebind_screenshot, rebind_run_lua, and rebind_key to drive Safari to Hacker News

02 · the plan

The agent picks its tools

The model reads the constraint and reaches for the Rebind toolkit on its own: screenshot the desktop, open Safari, navigate, read the results off the screen, paginate if it has to.

Safari on the Hacker News front page, opened and navigated by the agent through Rebind

03 · the hands

Safari, actually driven

Not a headless browser, not an API. Safari is really open and really on the front page, and the agent reads the same pixels you would — its input having arrived as real HID events.

The finished JSON output: three AI-related Hacker News stories with title, url, and points fields

04 · the result

Structured data back

Three AI stories as clean JSON — titles, URLs, points — in 38.5 seconds for $0.04 on Claude Haiku. Read from the screen, returned as data.

Real USB HID

Typed by hardware, not injected by software.

Screen agents normally synthesize OS events, and applications can tell. Rebind is different by construction: the agent's intent leaves the MCP server, crosses Rebind Link, and arrives at the computer as input from a physical USB HID device.

software mode

Start with the free engine

No hardware required. In software mode the Rebind Engine captures and emits input through operating system input APIs, and every tool on this page works exactly the same way. Learn the loop, build the workflow, and decide whether the agent earns a device.

hardware mode

Graduate to the real device

Rebind Link plugs in as its own USB device and performs the input itself. The computer sees a keyboard and a mouse, because that is what is on the wire. The agent inherits the whole path: same enumeration, same reports, same timing model as the hardware on your desk.

Connect an agent

One command per client.

Install the Rebind app, start the remote script from the Rebind UI, and register the MCP server with whichever clients you use. The same command configures Claude Code, Codex, Cursor, and more.

One command, then restart the client.

$npx add-mcp "bunx @rebind.gg/mcp-server" --name rebind -g -a claude-code

Requires the Rebind app with the remote script running. Verify the connection anytime with bunx @rebind.gg/mcp-server --selftest

GitHub npm package Documentation

The toolkit

Small tools an agent can trust.

Each tool does one thing and reports exactly what happened. Results come back in the pixel space of the last screenshot, so no rescaling math ever falls on the model.

perception

See before acting

Capture a display or a single window by title, then zoom into a region at native resolution when the text is too small to read.

screenshotscreenshot_windowzoom

pointer

Clicks that land

Move to a point and click with left, right, middle, or double. The landing position is verified against the real cursor and corrected before pressing.

clickmove_mousescroll

keyboard

Keys and text

Type into the focused element or press any key and combo, from Enter to LCtrl+L to LAlt+Tab.

typekey

windows

Windows and displays

Enumerate displays and windows, read the active window, and bring any window to the front by title substring.

list_windowsfocus_windowactive_windowlist_displays

scripting

Deterministic sequences

Launch apps, place windows, run shell commands, or search pixels in a single Luau script. The full SDK type definitions ship as a tool the agent can read.

run_lualua_docs

control

Timing and calibration

Read the cursor back, pause between steps, and probe the mouse scale so pointer ballistics never break the pixel math.

get_cursorwaitcalibrate

The Lua SDK

Clicking is the fallback. Scripting is the leverage.

Behind the click tools sits the full Rebind scripting SDK, and run_lua hands it to the agent dynamically. Anything a published Rebind script can do, the agent can write on the spot, execute on your machine, and read back as data.

one round trip

Script instead of click

A sequence that would take a dozen screenshot and click cycles collapses into one run_lua call: launch the app, place the window, read the pixel, type the result, return JSON. Deterministic work runs at script speed, and the agent spends its reasoning on the steps that actually need judgment.

run_lua

surface area

The whole engine is callable

The SDK that marketplace scripts are built on is the SDK the agent gets. HID input, screen capture and pixel search, window control, macro record and playback, files, networking, regex, JSON, timers, clipboard, and dialogs are all one script away.

hidscreenwindowmacrofilenettimer

self-documenting

The SDK explains itself

lua_docs returns the full type definitions for every namespace. The agent reads the contract, writes against it, and gets the script's return value back as structured JSON instead of parsing pixels off a screenshot.

lua_docs

repeatability

Solve once, replay forever

The agent can record input as a macro and replay it, schedule timers, and watch a screen region for change. A task solved once becomes a routine the agent triggers, not a conversation it repeats from scratch.

macrotimerscreen watch

Agentic control

An agent is only as capable as its hands.

Language models already know what to do. Rebind gives them the hands and the SDK to do it on the computer in front of you.

Download free Documentation