Skip to content
Back to search

eyra

MarketplaceWorks with Claude CodeGitHub

EYRA: Eye + Ear + Action for AI agents on Windows.

Safety scan

A static text scan, not a guarantee. Select the badge to see what was scanned and every finding.

Badge for your README
findsafeskills safety rating

Markdown

[![findsafeskills safety rating](/api/listings/layer8labs8--eyra/badge.svg)](/listings/layer8labs8--eyra)

HTML

<a href="/listings/layer8labs8--eyra"><img src="/api/listings/layer8labs8--eyra/badge.svg" alt="findsafeskills safety rating" /></a>

Install

Install instructions from the README

As written by the repo's author. findsafeskills has not verified these steps.

One-click install

| Agent | How | |---|---| | **Claude Desktop** | Download `eyra-<version>.mcpb` from the [latest release](https://github.com/layer8labs8/EYRA/releases/latest) and open it (double-click, or drag it into *Settings → Extensions*). A *Read-only mode* switch is available in the extension's settings. | | **Gemini CLI** | `gemini extensions install https://github.com/layer8labs8/EYRA` | | **Claude Code** | `/plugin install eyra --marketplace layer8labs8/EYRA` |

All packages contain the same standalone `eyra.exe`; nothing else is installed.

Download

1. Download `eyra.exe` from the [latest release](https://github.com/layer8labs8/EYRA/releases/latest). Or take the `.zip`, which also includes `SKILL.md`, the example MCP config and the license. 2. Put it anywhere, for example `C:\Tools\eyra\eyra.exe`. Nothing else needs to be installed: it runs on a stock Windows 10/11. 3. Connect it to your agent (see below).

The binary isn't code-signed yet, so Windows SmartScreen may show a warning on first run: choose *More info* → *Run anyway*. You can check the download against the SHA-256 published with the release:

Get-FileHash .\eyra.exe -Algorithm SHA256

Build from source

Requirements: Windows 10/11 and a stable Rust toolchain. The repo pins `stable-x86_64-pc-windows-gnu`, which needs MinGW-w64. To use MSVC instead, delete `rust-toolchain.toml`.

cargo build --release
# -> target\release\eyra.exe (~1.9 MB, no DLLs needed)
cargo test --release

To build every release asset (exe, zip, Claude `.mcpb`, Gemini extension archive, checksums) into `dist\`:

powershell -ExecutionPolicy Bypass -File scripts\package.ps1

Connect it to an agent

EYRA speaks standard MCP over stdio, so the setup is the same everywhere: point the host at `eyra.exe mcp`.

| Host | Where to add it | |---|---| | **Gemini – Antigravity** | MCP servers → *Manage* → *View raw config* (`mcp_config.json`), add the JSON below | | **Gemini CLI** | `gemini extensions install https://github.com/layer8labs8/EYRA`, or `%USERPROFILE%\.gemini\settings.json` with the JSON below | | **Claude Code** | `claude mcp add eyra -- C:\path\to\eyra.exe mcp` | | **Claude Desktop** | open the `.mcpb` from the release, or `claude_desktop_config.json` with the JSON below | | **Cursor / VS Code / others** | the host's MCP config file, add the JSON below |

See [`mcp-config.example.json`](mcp-config.example.json):

{
  "mcpServers": {
    "eyra": { "command": "C:\\path\\to\\eyra.exe", "args": ["mcp"] }
  }
}

Use `"args": ["mcp", "--read-only"]` to expose only the Eye, Ear and Watch tools, with no mouse or keyboard.

The server negotiates MCP revisions `2025-06-18`, `2025-03-26` and `2024-11-05`. It sends usage `instructions` on `initialize` and marks every tool with `readOnlyHint`/`destructiveHint` annotations, so hosts can auto-approve observation tools and ask before input actions.

**Agent skill.** [`SKILL.md`](SKILL.md) teaches an agent the lowest-token workflow.

What was scanned

The files the safety scan read, as written by the repository's author and shown as plain text. Lines with a finding are marked.

.claude-plugin/marketplace.json · Manifest · 15 lines
  1. {
  2. "name": "eyra",
  3. "description": "EYRA: Eye + Ear + Action for AI agents on Windows.",
  4. "owner": {
  5. "name": "layer8labs8",
  6. "url": "https://github.com/layer8labs8"
  7. },
  8. "plugins": [
  9. {
  10. "name": "eyra",
  11. "source": "./claude-plugin",
  12. "description": "Eye + Ear + Action for Windows: see any app as compact text (UI Automation + OCR), hear system audio and the mic, and control mouse and keyboard."
  13. }
  14. ]
  15. }
README.md · README · 274 lines
  1. <p align="center">
  2. <img src="assets/eyra-banner.jpg" alt="EYRA — Eye + Ear + Action" width="760"/>
  3. </p>
  4. <h1 align="center">EYRA</h1>
  5. <p align="center">
  6. <strong>Eye + Ear + Action</strong> for AI agents on Windows.<br/>
  7. One ~1.9 MB pure-Rust binary that is an <strong>MCP server</strong>, an <strong>agent skill</strong> and a <strong>CLI</strong>.<br/>
  8. It sees any window as compact text, hears system audio and the microphone, and drives the mouse and keyboard.<br/>
  9. Works with any MCP-capable agent: <strong>Gemini</strong> (Antigravity, Gemini CLI), <strong>Claude</strong> (Claude Code, Claude Desktop), <strong>Cursor</strong>, VS Code and others.
  10. </p>
  11. <p align="center">
  12. <a href="https://github.com/layer8labs8/EYRA/releases"><img alt="Downloads" src="https://img.shields.io/github/downloads/layer8labs8/EYRA/total?label=downloads&color=2EA44F"/></a>
  13. <a href="https://github.com/layer8labs8/EYRA/releases/latest"><img alt="Latest release" src="https://img.shields.io/github/v/release/layer8labs8/EYRA?label=release"/></a>
  14. <a href="https://github.com/layer8labs8/EYRA/stargazers"><img alt="GitHub stars" src="https://img.shields.io/github/stars/layer8labs8/EYRA?style=flat"/></a>
  15. <img alt="License: Apache-2.0" src="https://img.shields.io/badge/License-Apache_2.0-blue.svg"/>
  16. <img alt="Platform: Windows 10/11" src="https://img.shields.io/badge/platform-Windows%2010%20%7C%2011-0078D6"/>
  17. <img alt="MCP 2025-06-18" src="https://img.shields.io/badge/MCP-2025--06--18-6E56CF"/>
  18. <img alt="Tests: 40 passing" src="https://img.shields.io/badge/tests-40%20passing-2EA44F"/>
  19. </p>
  20. https://github.com/user-attachments/assets/023b3238-3dee-4a1b-b20c-65e0447f14b8
  21. ---
  22. ## Why EYRA?
  23. Most computer-use agents send a full screenshot on every step and then guess pixel coordinates. EYRA reads what Windows already knows about the screen. Example `see` output (abridged):
  24. ```text
  25. WIN hwnd=0x3C051E proc=chrome.exe title="New repository - Google Chrome" mode=uia ms=22
  26. #15 inp "Address and search bar" val="github.com/new" [158,46,1060,34]
  27. #49 cmb "Owner" val="octocat" [325,333,150,32]
  28. #51 inp "Repository name *" (focused) [496,333,530,32]
  29. #68 chk "Add README" (unchecked) [978,682,42,24]
  30. ```
  31. - **Exact, not guessed.** The text and coordinates come from the OS accessibility tree, so the agent doesn't have to estimate them from pixels. `click(id=51)` hits the right control.
  32. - **Fewer tokens.** A text map of the UI is cheaper than a screenshot. `see_diff` returns only what changed, typically **under 40 tokens per step**.
  33. - **Not just the web: the whole Windows desktop.** Any browser (Chrome, Edge, Firefox, Brave; including logged-in tabs), File Explorer, Office, Settings, Notepad, Electron apps (VS Code, Discord, Slack, Telegram), canvases, games and video (through OCR). No browser extension, per-site API or cloud service.
  34. - **Model-agnostic.** It is a standard MCP server, so the same binary serves Gemini, Claude, GPT-based hosts or your own agent. Models that accept audio input (for example Gemini) can listen to the WAV clips that `listen` / `watch` produce. Text-only models still get Eye + Action.
  35. - **Zero runtime dependencies.** No Python, FFmpeg, Whisper or API keys. Only Windows APIs: UI Automation, WinRT OCR, WASAPI and SendInput.
  36. - **Safe by default.** Password values are masked, password managers are blocked, there's a `--read-only` mode, a failsafe corner, a kill-switch hotkey and an audit log.
  37. ## Measured performance
  38. Measured on Windows 10 at 1366×768 with `eyra bench` and the MCP server.
  39. ### Latency of `see` (one window)
  40. | Mode | Chrome (GitHub page, ~100 elements) | Electron desktop app |
  41. |---|---|---|
  42. | MCP server, warm (`see`) | **22 ms** | ~25 ms |
  43. | MCP server, warm (`see_diff`) | **23 ms** | ~25 ms |
  44. | CLI, one-shot process | ~45 ms | ~65 ms |
  45. | OCR mode (`mode="ocr"`) | ~80 ms | ~80 ms |
  46. File Explorer showing a very large folder is the slowest case tested: ~195 ms.
  47. ### Tokens per observation
  48. Each window is compared with one screenshot of the same window (image tokens = w·h/750). Text tokens are estimated as chars/4.
  49. | Window (screenshot cost) | `see` | `interactive_only` | `interactive_only` + `coords="center"` | `see_diff` (no change) |
  50. |---|---|---|---|---|
  51. | Chrome, dense GitHub repo page, 1036×701 (~969) | ~1,137 | ~1,065 | **~901 (−7%)** | **~42 (−96%)** |
  52. | Electron desktop app, 1366×728 (~1,326) | ~675 | ~603 | **~528 (−60%)** | **~28 (−98%)** |
  53. | Windows desktop / Explorer, 1366×768 (~1,399) | ~294 | ~294 | **~250 (−82%)** | **~31 (−98%)** |
  54. **How to read this:**
  55. - The first look at a very dense web page costs about as much as a screenshot, but it gives exact `#id`s and coordinates instead of pixels to guess.
  56. - The big savings come from the steps after that. A 20-step task that observes with `see_diff` costs about 900 + 19×40 ≈ **1.7k tokens instead of about 19–26k** with screenshots.
  57. Run it on your own machine:
  58. ```powershell
  59. eyra bench --window Chrome
  60. ```
  61. ## When to use EYRA (and when not)
  62. | Task | Best tool |
  63. |---|---|
  64. | Native Windows apps (Explorer, Office, Settings, Telegram, WinForms/WPF/UWP) | **EYRA** |
  65. | Electron apps (VS Code, Slack, Discord, Teams) | **EYRA** |
  66. | Repeatedly watching the same window for changes | **EYRA** `see_diff` / `wait_change` |
  67. | Canvas, games, remote desktop, video | **EYRA** `see(mode="ocr")` / `screenshot(diff_only)` |
  68. | Hearing system audio or the microphone (for audio-capable models) | **EYRA** `listen` / `watch_*` |
  69. | Deep web automation: hidden DOM, network, console, JS | A browser-extension tool (DOM access beats OS-level access here) |
  70. EYRA can only see what's on screen. It can't read DOM nodes that aren't rendered, network traffic or a page's JavaScript state.
  71. ## Install
  72. ### One-click install
  73. | Agent | How |
  74. |---|---|
  75. | **Claude Desktop** | Download `eyra-<version>.mcpb` from the [latest release](https://github.com/layer8labs8/EYRA/releases/latest) and open it (double-click, or drag it into *Settings → Extensions*). A *Read-only mode* switch is available in the extension's settings. |
  76. | **Gemini CLI** | `gemini extensions install https://github.com/layer8labs8/EYRA` |
  77. | **Claude Code** | `/plugin install eyra --marketplace layer8labs8/EYRA` |
  78. All packages contain the same standalone `eyra.exe`; nothing else is installed.
  79. ### Download
  80. 1. Download `eyra.exe` from the [latest release](https://github.com/layer8labs8/EYRA/releases/latest). Or take the `.zip`, which also includes `SKILL.md`, the example MCP config and the license.
  81. 2. Put it anywhere, for example `C:\Tools\eyra\eyra.exe`. Nothing else needs to be installed: it runs on a stock Windows 10/11.
  82. 3. Connect it to your agent (see below).
  83. The binary isn't code-signed yet, so Windows SmartScreen may show a warning on first run: choose *More info* → *Run anyway*. You can check the download against the SHA-256 published with the release:
  84. ```powershell
  85. Get-FileHash .\eyra.exe -Algorithm SHA256
  86. ```
  87. ### Build from source
  88. Requirements: Windows 10/11 and a stable Rust toolchain. The repo pins `stable-x86_64-pc-windows-gnu`, which needs MinGW-w64. To use MSVC instead, delete `rust-toolchain.toml`.
  89. ```powershell
  90. cargo build --release
  91. # -> target\release\eyra.exe (~1.9 MB, no DLLs needed)
  92. cargo test --release
  93. ```
  94. To build every release asset (exe, zip, Claude `.mcpb`, Gemini extension archive, checksums) into `dist\`:
  95. ```powershell
  96. powershell -ExecutionPolicy Bypass -File scripts\package.ps1
  97. ```
  98. ### Connect it to an agent
  99. EYRA speaks standard MCP over stdio, so the setup is the same everywhere: point the host at `eyra.exe mcp`.
  100. | Host | Where to add it |
  101. |---|---|
  102. | **Gemini – Antigravity** | MCP servers → *Manage* → *View raw config* (`mcp_config.json`), add the JSON below |
  103. | **Gemini CLI** | `gemini extensions install https://github.com/layer8labs8/EYRA`, or `%USERPROFILE%\.gemini\settings.json` with the JSON below |
  104. | **Claude Code** | `claude mcp add eyra -- C:\path\to\eyra.exe mcp` |
  105. | **Claude Desktop** | open the `.mcpb` from the release, or `claude_desktop_config.json` with the JSON below |
  106. | **Cursor / VS Code / others** | the host's MCP config file, add the JSON below |
  107. See [`mcp-config.example.json`](mcp-config.example.json):
  108. ```json
  109. {
  110. "mcpServers": {
  111. "eyra": { "command": "C:\\path\\to\\eyra.exe", "args": ["mcp"] }
  112. }
  113. }
  114. ```
  115. Use `"args": ["mcp", "--read-only"]` to expose only the Eye, Ear and Watch tools, with no mouse or keyboard.
  116. The server negotiates MCP revisions `2025-06-18`, `2025-03-26` and `2024-11-05`. It sends usage `instructions` on `initialize` and marks every tool with `readOnlyHint`/`destructiveHint` annotations, so hosts can auto-approve observation tools and ask before input actions.
  117. **Agent skill.** [`SKILL.md`](SKILL.md) teaches an agent the lowest-token workflow.
  118. ## MCP tools (16)
  119. ### Eye
  120. | Tool | What it does | Key arguments |
  121. |---|---|---|
  122. | `list_windows` | Visible windows: hwnd, process, title, rect, flags | — |
  123. | `see` | Numbered UI element map (UIA, OCR fallback); includes open popup menus | `window`, `mode` = auto/uia/ocr/both, `interactive_only`, `coords` = rect/center, `max_elements`, `ocr_lang` |
  124. | `see_diff` | Only `+` added, `~` changed and `-` removed elements since the last `see` of **that window** | same as `see` |
  125. | `screenshot` | Compact JPEG/PNG, including occluded windows | `window`, `crop`, `max_width`, `quality`, `diff_only`, `som` |
  126. | `wait_change` | Blocks until the pixels change (page load, animation end) | `window`, `timeout_ms`, `threshold_pct` |
  127. ### Ear and Watch
  128. | Tool | What it does | Key arguments |
  129. |---|---|---|
  130. | `list_audio_devices` | Output (loopback) and input endpoints | — |
  131. | `listen` | Records system audio, the mic, or both, trims silence, saves a 16 kHz WAV | `seconds`, `source`, `trim_silence` |
  132. | `watch_start` / `watch_poll` / `watch_stop` | Rolling timeline of scene-change keyframes and audio clips | `window`, `audio`, `chunk_sec`, `scene_threshold_pct` |
  133. ### Action (disabled in `--read-only`)
  134. | Tool | What it does | Key arguments |
  135. |---|---|---|
  136. | `click` | Clicks by `#id` (background UIA Invoke/Toggle/Select first) or by `x,y` | `id`, `x`, `y`, `button`, `clicks`, `background` |
  137. | `type_text` | Types Unicode text (background UIA `SetValue` first) | `text`, `id`, `clear`, `press_enter` |
  138. | `hotkey` | Sends a keyboard shortcut such as `ctrl+l` or `alt+tab` | `keys`, `window` |
  139. | `scroll` / `drag` | Scrolls the mouse wheel or drags with the left button | `delta_y`, `delta_x` / `x1,y1,x2,y2` |
  140. | `focus_window` | Restores, focuses and optionally locks a default target window | `window`, `lock` |
  141. ### Reading the element map
  142. ```text
  143. #12 btn "Save" (disabled) [840,610,90,32]
  144. │ │ │ │ └ x,y,width,height in screen pixels
  145. │ │ │ └ state: focused, disabled, checked, unchecked, mixed, selected
  146. │ │ └ accessible name (val="…" follows when an input has a value)
  147. │ └ role: btn inp lnk chk rad cmb tab mnu itm sld hdr txt img doc pwd ocr el
  148. └ id: pass it to click / type_text
  149. ```
  150. With `coords="center"` the position is printed as the click point only (`#12 btn "Save" (disabled) @885,626`), which is the cheapest format.
  151. `#id`s come from the **most recent `see`/`see_diff`** of that window, so call `see_diff` again after the UI changes. Open popup menus (File/Edit menus, context menus) are part of the window's map.
  152. ## CLI
  153. ```powershell
  154. eyra windows
  155. eyra see --window Chrome --interactive-only --coords center
  156. eyra diff --window Chrome
  157. eyra screenshot --window Chrome --som --out som.jpg
  158. eyra click --id 5
  159. eyra type "hello world" --id 2 --enter
  160. eyra hotkey ctrl+l
  161. eyra wait-change --window Chrome
  162. eyra audio-devices
  163. eyra listen --seconds 8 --source both
  164. eyra watch --window Chrome --duration 60
  165. eyra ocr-langs
  166. eyra logs --tail 25
  167. eyra bench --window Chrome
  168. eyra serve --port 47821 # optional 127.0.0.1 HTTP bridge (token-authenticated)
  169. ```
  170. `--window` accepts an hwnd (`0x3C051E`), a title substring, a process name or `screen`. Add `--json` for machine-readable output.
  171. ## Safety
  172. | Guard | Behaviour |
  173. |---|---|
  174. | Password fields | Values are always shown as `[REDACTED]` and blacked out in screenshots and before OCR |
  175. | Sensitive windows | 1Password, KeePass, Bitwarden and Windows Security can't be read or controlled unless you pass `--allow-sensitive` |
  176. | `--read-only` | Removes all input tools from the MCP tool list and rejects them in the CLI and bridge |
  177. | Corner failsafe | Moving the mouse to the top-left corner `(0,0)` halts input actions |
  178. | Kill switch | `Ctrl+Alt+Esc` latches an emergency stop until eyra restarts |
  179. | Dangerous hotkeys | `ctrl+alt+delete` and `win+l` are blocked, and so is `alt+f4` on the Windows shell |
  180. | Audit log | JSONL at `%LOCALAPPDATA%\eyra\audit.jsonl`: every call with its timing and token estimate. Text typed into password fields is redacted. Rotates at 10 MB |
  181. ## Troubleshooting
  182. | Symptom | Cause and fix |
  183. |---|---|
  184. | `see` says the window is minimized | Restore it first with `focus_window`. |
  185. | `see` returns nearly nothing for a game, canvas or remote desktop | There is no UIA tree there. Use `mode="ocr"`; `auto` already falls back to OCR below 5 elements. |
  186. | OCR misses your language | Run `eyra ocr-langs`, then install the language's OCR pack in Windows Settings → Time & Language → Language, and pass `ocr_lang`. |
  187. | Clicks or typing do nothing in an admin window | Windows UIPI blocks input to elevated windows from a non-elevated process. Run eyra elevated, or the target app non-elevated. |
  188. | Coordinates are off on a multi-monitor or 150% DPI setup | eyra is per-monitor DPI aware and coordinates are physical pixels. Use `#id` clicks rather than hand-computed points. |
  189. ### Environment variables
  190. | Variable | Effect |
  191. |---|---|
  192. | `EYRA_LOG_FILE` / `EYRA_NO_LOG` | Audit log path / disable logging |
  193. | `EYRA_READ_ONLY` | Forces read-only mode |
  194. | `EYRA_OCR_SCALE=2` | Upscales frames before OCR (slower; can help with very small text) |
  195. ## Architecture
  196. ```text
  197. src/
  198. ├─ eye/ uia.rs (cached UIA subtree scan) · ocr.rs (WinRT OCR) · capture.rs (PrintWindow/BitBlt)
  199. │ diff.rs (element and pixel diff) · som.rs (Set-of-Mark badges) · windows.rs
  200. ├─ ear/ wasapi.rs (loopback + mic) · vad.rs (resample + energy VAD) · wav.rs
  201. ├─ hand.rs UIA patterns → SendInput fallback
  202. ├─ watch.rs ring-buffered video and audio timeline
  203. ├─ mcp.rs stdio JSON-RPC server ├─ bridge.rs local HTTP bridge
  204. ├─ safety.rs · audit.rs · state.rs └─ cli.rs
  205. ```
  206. ## License
  207. Licensed under the [Apache License 2.0](LICENSE).

Ratings and comments

Sign in to rate this skill.

Sign in

Free to use. If it’s helped, pass it on.