Skip to main content
Glama

glass_start

Launch a native GUI app and return its window geometry. Optionally specify backend, build command, environment, working directory, sandbox, timeout, and window hint to control the launch.

Instructions

Build, launch, and locate a native GUI app; returns its window geometry. Choose a backend with the backend param (defaults to the host). The accessibility tools are enabled by default; pass a11y:false to skip the accessibility bus for canvas/pixel-only apps. Optional window_hint ({ title?, class? }) picks the right window when several appear, or locates one the launched process hands off to another process.

Input Schema

TableJSON Schema
NameRequiredDescriptionDefault
cwdNoWorking directory for both `build` and the launched app; omit to inherit the server's own.
envNoExtra environment variables, as a `{ "KEY": "VALUE" }` object. They reach the launched app on the desktop backends and on `ios`; on `android` they configure the `build` command on the host only, since an app launched by `am start` is forked from zygote and never sees the shell's environment.
runYesWhat to launch, then its arguments. `run[0]` is the executable on a desktop backend, an `.app` path or bundle id on `ios`, and a `package/.Activity` component — optionally with an `.apk` to install first — on `android`. `run[1..]` are the app's own arguments; `android` has no argument vector to put them in and returns an error rather than ignoring them.
a11yNoSpawn a private accessibility (AT-SPI) bus so `glass_a11y_snapshot` / `marks` / `set_value` / `click_element` / `wait_for_element` work against this app. **On by default** — the accessibility path is the cheap, low-token way to drive a UI, so it is available unless you opt out. Pass `false` to skip the bus for canvas/pixel-only apps (it spawns extra processes). Effective on Linux only; other backends read accessibility ambiently and ignore this flag.
buildNoOptional shell command to run (in `cwd`) before launching.
backendNoBackend to launch under: `"x11"` or `"wayland"` (Linux), `"windows"` (on a Windows host), `"macos"` (on a macOS host), `"android"` (an AVD emulator, any host), or `"ios"` (an iOS Simulator, macOS host). Omit for the server default (`GLASS_BACKEND`, else `windows` on Windows, `macos` on macOS, else x11).
sandboxNoContainment level for the launched app: `"default"` (filesystem/process containment, network on), `"strict"` (also no network), or `"off"` (no containment). Omit for the server default (`GLASS_SANDBOX`, else `default`). An operator-set floor (`GLASS_SANDBOX_FLOOR`) may raise an omitted level, and refuses an explicit level requested below it.
timeout_msNoHow long to wait for the app's window to appear before failing the launch (default 10000ms). Does not bound `build`.
window_hintNoOptional `{ title?, class? }` to disambiguate which window is the app's when more than one appears, or to find a window the launched process hands off to an unrelated process. Omit to take the first window owned by the launched process or a descendant it can follow.
Behavior4/5

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

Adds behavioral context beyond annotations: explains that a11y is on by default, that passing false skips the accessibility bus for canvas apps, and that window_hint handles multi-window or handoff cases. This supplements the sparse annotations (readOnlyHint=false, destructiveHint=false) with useful details about defaults and side effects.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Conciseness5/5

Is the description appropriately sized, front-loaded, and free of redundancy?

The description is four sentences, front-loaded with the core purpose, and each sentence adds distinct value (backend, a11y, window_hint) without fluff or repetition. Every sentence earns its place.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Completeness4/5

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

For a tool with 9 parameters and a nested object, the description covers the most critical aspects (purpose, backend, a11y, window_hint) while leaving parameter details to the schema. It doesn't explicitly mention return format beyond 'window geometry' (no output schema), but that is adequate for the complexity. Minor gap: it doesn't summarize the env behavior on android or the timeout, but these are clearly documented in the schema.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Parameters4/5

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

With 100% schema coverage, the baseline is 3, but the description adds value: it explains the backend default, gives a pragmatic reason for a11y:false (canvas/pixel-only apps), and clarifies window_hint's purpose. This goes beyond simply repeating schema descriptions.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Purpose5/5

Does the description clearly state what the tool does and how it differs from similar tools?

The description states a specific verb+resource: 'Build, launch, and locate a native GUI app; returns its window geometry.' This clearly distinguishes it from sibling tools like glass_list_windows (which lists windows) and glass_select_window (which selects), making the tool's purpose unambiguous.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Usage Guidelines4/5

Does the description explain when to use this tool, when not to, or what alternatives exist?

Provides clear usage context: how to choose a backend, when to pass a11y:false, and how to use window_hint for disambiguation. However, it does not explicitly mention alternatives like 'use glass_list_windows if you just need to list windows,' so it lacks explicit exclusions, but the purpose is distinct enough that context is clear.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

Install Server

Other Tools

Latest Blog Posts

MCP directory API

We provide all the information about MCP servers via our MCP API.

curl -X GET 'https://glama.ai/api/mcp/v1/servers/fixed-width/glass'

If you have feedback or need assistance with the MCP directory API, please join our Discord server