UI-TARS-desktop

Enables autonomous desktop/web UI interaction by capturing screenshots, analyzing them with vision-language models (VLM), and executing click/type/scroll actions based on visual understanding. The system uses a closed-loop action cycle: screenshot → VLM analysis → action generation → execution, with support for both local VLM providers (Doubao-1.5-UI-TARS) and remote OpenAI-compatible endpoints. The GUIAgent SDK abstracts operator implementations for different platforms (local desktop via Electron, remote via VNC).

Provides a plugin-based agent architecture (ComposableAgent) that dynamically routes tasks to specialized sub-agents: GUI automation, code execution, web browsing, and MCP tool integration. Each plugin implements a standardized interface and receives context from a central orchestrator, enabling agents to delegate work (e.g., 'execute this Python code' → CodeAgent, 'click the login button' → GUIAgent). The system uses a T5 format streaming parser to handle tool calls and agent responses in a structured, resumable manner.

Integrates semantic search capabilities that enable agents to query the web, process results, and extract relevant information. The system supports multiple search backends (Google, Bing, custom search engines) and ranks results using semantic similarity and relevance scoring. Search results are formatted for agent consumption with metadata (URL, snippet, ranking score). The search integration is exposed as a tool that agents can invoke as part of their workflows.

Provides a hook-based extension system where developers can register callbacks at key agent lifecycle points (before/after tool calls, on errors, on completion). Hooks receive full context (agent state, tool call details, results) and can modify behavior (e.g., logging, metrics collection, custom error handling). The system supports both synchronous and asynchronous hooks, with error handling to prevent hook failures from breaking agent execution.

Implements a processing pipeline that sends agent context and tool calls to LLMs with streaming response handling. The pipeline manages token counting, context window management, and response parsing. It supports streaming responses where tokens are processed incrementally, enabling real-time UI updates and early stopping. The pipeline handles different LLM response formats (OpenAI, Anthropic, etc.) and normalizes them into a unified agent response format.

Implements the core agent execution loop that repeatedly calls the LLM, executes tool calls, and processes results until completion or max-step limit. The runner handles errors gracefully with retry logic and fallback strategies. It maintains execution state (current step, tool calls, results) and can pause/resume execution. The runner enforces safety limits (max steps, timeout) to prevent infinite loops and resource exhaustion.

Provides browser control capabilities through Playwright/Puppeteer integration with semantic element understanding. The system can navigate URLs, interact with form elements, extract content, and perform searches using integrated search infrastructure. It supports both direct element selection (via CSS/XPath) and semantic interaction (via VLM-based element identification). The browser automation layer integrates with the search system to handle web queries and result processing within agent workflows.

The CodeAgent plugin executes arbitrary code (Python, JavaScript, etc.) in isolated sandbox environments with resource limits, capturing stdout/stderr and return values. The system uses containerized or process-level isolation to prevent malicious code from accessing the host system. Execution results are streamed back to the agent with full error context, allowing the agent to handle failures and retry with modified code. Integration with the agent loop enables iterative code refinement based on execution feedback.

Implements an MCP client that discovers, registers, and invokes tools from MCP servers (local and remote). The system maintains a tool registry with schema information, handles tool call serialization/deserialization, and manages MCP server lifecycle (startup, shutdown, reconnection). The MCP agent plugin routes tool calls from the main agent to appropriate MCP servers, with support for multiple concurrent MCP server connections. Transport layer supports stdio, HTTP, and WebSocket protocols for MCP communication.

Implements a streaming event architecture where agent execution produces a continuous stream of structured events (tool calls, responses, state changes) in T5 format. The T5 format uses delimited markers to structure tool calls and responses, enabling partial parsing and resumable execution. Events are streamed to clients in real-time, allowing UI updates and external monitoring. The streaming parser handles incomplete messages and can resume parsing from arbitrary points, supporting long-running agent sessions with network interruptions.

Manages agent session creation, execution, and state persistence through a REST API (AgentSession). Each session maintains execution history, tool call logs, and agent state, with support for querying and resuming sessions. Sessions are persisted to a backend store (database or file system), enabling long-lived agent workflows that survive server restarts. The session API provides endpoints for creating sessions, submitting queries, streaming results, and retrieving execution history.

Provides a web-based UI for agent configuration, execution, and monitoring through a React-based frontend with dynamic routing. The UI supports creating and managing agent sessions, configuring tool integrations, viewing execution traces, and accessing workspace resources (files, code, etc.). The configuration system allows runtime modification of agent settings without restarting the server. Workspace navigation enables browsing and managing files created by agents during execution.

Packages the UI-TARS agent stack as a native Electron desktop application with dual automation modes: local (direct screenshot/input on the same machine) and remote (VNC-based control of remote machines). The application manages system permissions for screenshot and input simulation, handles VNC connection lifecycle, and provides a native UI for agent configuration and execution. The Electron main process bridges between the renderer (React UI) and native system APIs for screenshot capture and input simulation.

Abstracts vision-language model providers (OpenAI, Claude, Gemini, local Doubao-1.5-UI-TARS) behind a unified interface, enabling agents to switch between models without code changes. The system handles provider-specific API differences (request/response formats, authentication), manages API quotas and rate limits, and supports fallback routing when a provider is unavailable. Configuration allows specifying primary and fallback models, with automatic failover on errors.