AUV means Application Use Via ...: a Rust-first runtime for explicit, inspectable desktop operations.

Think of it as a programmable computer use, without agents.

Current public support levels and platform limits are tracked in the support matrix.

Install

Install Rust first. This workspace uses Rust 2024 and currently requires the toolchain declared in Cargo.toml.

Install directly from GitHub. CI validates the same Cargo Git-source package/bin shape from a local, commit-pinned snapshot; it does not exercise GitHub network fetch availability:

cargo install --git https://github.com/moeru-ai/auv auv-cli --bin auv
auv --help

After installation, use the auv CLI directly:

auv --help
auv --version
auv invoke --help

The matrix names the evidence level and known limits behind every public capability claim. AUV does not treat a compiled driver or fixture test as proof of live desktop support.

Setup

macOS Permissions

macOS automation needs OS permissions granted to the process that launches AUV, usually your terminal app.

Open System Settings -> Privacy & Security and enable:

Permission	Needed for
Accessibility	AX tree reads, focused element control, keyboard/pointer automation.
Screen Recording	Screenshots, OCR, visual inspection, and evidence capture.
Automation	AppleScript/System Events activation flows used by app probes and some drivers.

After changing permissions, restart the terminal process and rerun:

auv permissions check
auv app probe com.apple.TextEdit

Understand AUV

For Cua, agent-browser, and similar computer-use projects, it is common to execute screenshot, read image, click, type, wait, and follow-up verification steps in sequence, then ask LLMs or agents to judge the next move.

flowchart LR
  A[Agent] --> B[screenshot]
  B --> C[read image]
  C --> D[decide next step]
  D --> E[click]
  E --> F[wait]
  F --> G[type]
  G --> H[verify]
  H --> D

Many of those repeated sequences can be squashed into reusable GUI operations. Opening an app, waiting for readiness, filling a form, and checking the result should be callable as one command instead of spending tokens on the same step-by-step loop every time.

Modern agents often use skills or project instructions to orchestrate tool calls, CLIs, and scripts. But built-in computer-use surfaces, such as OpenAI Computer Use or Claude Computer Use, are still primarily interactive model-tool loops, not scriptable GUI automation libraries.

• Ran screenshot
  └ saved screen.png
• Ran read image screen.png
  └ form is visible
• Ran click "Email"
  └ clicked
• Ran type "[email protected]"
  └ typed
• Ran screenshot
  └ saved after.png
• Ran verify form state
  └ ready

pub fn open_and_fill_form(
  app: &mut AppSession,
  data: FormData,
) -> AuvResult<OperationResult> {
  app.open()?;
  app.wait_for_ready()?;
  app.fill(data)?;
  app.verify_submitted()
}

• Ran screenshot
  └ saved page-1.png
• Ran OCR visible rows
  └ 12 rows
• Ran scroll
  └ scrolled down
• Ran OCR visible rows
  └ 10 rows, 4 repeated
• Ran guess when to stop
  └ uncertain

pub fn scan_visible_rows(
  region: &mut WindowRegion,
) -> AuvResult<ScrollScanArtifact> {
  region.scan_rows_until_stop()
}

• Ran click target
  └ clicked
• Ran screenshot
  └ saved after-click.png
• Ran semantic check
  └ mismatch
• Ran retry manually
  └ repeated tool loop

pub fn verify_and_retry<F>(
  mut operation: F,
) -> AuvResult<OperationResult>
where
  F: FnMut() -> AuvResult<OperationResult>,
{
  retry_until_verified(&mut operation)
}

Similar to Playwright, AUV expects agents to write, test, and improve reusable GUI automations for E2E tests and rapid application actions.

AUV is not a computer-use agent. It does not ship an agent or harness. It offers tools, CLIs, drivers, and verifiable observable results so agents can build reusable GUI operations.

AUV is meant to work with coding agents and agent products such as:

Apeira
Codex
Claude Code
Pi Agent
LobeHub
Kimi CLI
... bring your own

That means:

If your agent can call a CLI, AUV can be used as computer use.
If your agent can write code, AUV can save tokens by moving repeated GUI work into Rust commands today. JavaScript/TypeScript and Python bindings are planned after the contracts settle; they are not shipped surfaces.

Why even build AUV?

AUV born from the grounding knowledge of building general gaming agents for Project AIRI, since 2024, we tried to build agents to allow LLMs to play the following games, you can find how we implement the agents in the following repos:

There are more games we implemented where you can find in Project AIRI organization, but these four requires YOLO, OCR, screen understanding, and computer-use capabilities.

Now you have the framework to build for any applications, games.

Since Vercel published the agent-browser, we fell in love with it and have it assisted agents to build many web projects, but we found that the loop it requires for agents to call agent-browser CLI to execute the commands is too slow and inefficient, while in computer use world, many operations can be repeated thousands of times, just like how Playwright/Vitest would allow us to write E2E test for applications, why don't we expand this idea of writing code to control application to computer use world?

Capability Evidence

The project records what a command attempted, what artifacts it captured, and what verification says. The public capability claim is intentionally narrower: it is only as strong as its current evidence level. Read the support matrix for platform-specific claims, evidence links, and known limits.

The matrix deliberately does not compare third-party feature checkmarks. Those claims require a separate upstream audit and would otherwise blur what this repository can prove.

Development

cargo fmt --check
cargo check
cargo test
git diff --check
cargo run -- --help
cargo run -- invoke --help

Useful entrypoints:

auv app probe <bundle-id>
auv app analyze .auv/app-probes/<probe>/probe.json
auv invoke <command-id> --help
auv inspect <run-id>

Use docs/TERMS_AND_CONCEPTS.md for shared vocabulary. Durable design and evidence notes live under docs/ai/references/.

[!NOTE]

This project is part of the Project AIRI ecosystem.

Acknowledgements

Special Thanks

Special thanks to all contributors for their contributions to auv ❤️

Star History

License

Apache License 2.0

Auv

README