Technical Deep Dive: Why Desktop Agents Fail & How VACT Solves Screen Perception ↗
VACT v1.0
Direct3D 11 • Rust Kernel • Named Pipe IPC • Windows 10/11

Direct GPU Screen Perception for Autonomous Desktop Agents

VACT eliminates screenshot-based Vision-Language Model latency. It captures display framebuffers directly in GPU VRAM, runs bilateral edge filtering and connected component labeling via compute shaders, and streams sub-2KB differential vector DAGs over local Win32 named pipes in under 20ms.

$ git clone https://github.com/fy2ne/VACT.git
Read fy2ne's Technical Manifesto ↗
1.2ms
DXGI Frame Capture
~8ms
GPU CCL Labeling
~10ms
Single-Pass WinRT OCR
<2 KB
Vector DAG Wire Size
0
Vision Bitmap Tokens
The Architectural Bottleneck

Why Screenshot VLMs Fail at Real Desktop Control

Vision-Language Models take screenshots, encode them to JPEG, upload them across the internet, and guess 2D coordinates. That pipeline is fundamentally unsuited for responsive desktop tasks.

Perception Attribute Screenshot VLMs (Claude Computer Use, etc.) VACT Direct GPU Kernel
Frame Extraction CPU GDI/PrintWindow encode to JPEG/PNG (40–120ms) Zero-copy VRAM surface via DXGI Desktop Duplication (1.2ms)
Per-Turn Latency 1,800ms – 4,500ms network round-trip 18ms – 22ms local compute cycle (up to 60 FPS capable)
Wire Payload 1.5 MB – 2.5 MB image data per step < 2 KB structured differential vector mutations
Token Consumption ~2,200 input tokens per step (~$0.05 / action) 0 image tokens; standard text tool calls only ($0.00 vision cost)
Target Precision Estimated visual coordinates (frequent hallucination & miss clicks) Mathematically exact centroid moments [cx, cy] computed via CCL
Video & Canvas Blindspots HTML5 videos, WebGL 3D, DirectX viewports blur or lag behind Direct photon extraction: analyzes whatever the GPU outputs to the display
Network & Privacy Desktop screen content sent to third-party cloud servers 100% air-gapped on-device Win32 Named Pipe (\\.\pipe\VACT)
Direct3D 11 Engine Architecture

The Zero-Copy GPU Perception Pipeline

VACT executes six deterministic stages entirely on your local machine to translate raw hardware display photons into structured vector ASTs.

01

DXGI Output Duplication

Directly binds to the Windows DWM display output via IDXGIOutputDuplication. Frames are acquired directly into a Direct3D 11 texture without CPU memory copying.

Timing: ~1.2ms
02

Bilateral Edge Filtering

An HLSL compute shader applies spatial and range Gaussian weighting in parallel across 64-thread workgroups. Denoises video playback artifacts while keeping pixel-sharp UI borders.

Timing: ~1.8ms
03

Connected Component Labeling

Parallel CCL kernel with stride-2 subsampling segments contiguous interactive UI controls, buttons, text fields, and icons into normalized bounding boxes.

Timing: ~8.2ms
04

Single-Pass WinRT OCR

Executes full-frame WinRT hardware OCR with automatic downsampling for 4K displays. Replaces legacy multi-crop COM calls, dropping text detection from 320ms to 10ms.

Timing: ~9.8ms
05

Vector Scene Graph Assembly

Correlates bounding boxes with OCR glyphs, resolves active window focus, associates taskbar applications, and computes exact sub-pixel centroid click targets [cx, cy].

Timing: ~0.4ms
06

Named Pipe IPC Streaming

Diff engine calculates monotonic mutations (INSERT / UPDATE / DELETE) and emits a sub-2KB framed frame over local pipe \\.\pipe\VACT directly to client SDKs.

Timing: ~0.1ms
Live Data Visualization

Interactive Vector Scene Graph Inspector

Hover over any detected desktop node below to inspect the exact JSON scene graph emitted by the VACT kernel to client agents. No fake SVGs — this is the real protocol schema.

Desktop Surface (1600 × 900) — Active: Notepad.exe VACT 60 FPS
WINDOW #1
MENUBAR #2
File
Edit
View
INPUT #6 (Focused)

VACT Direct3D11 Kernel Active... Listening on \\.\pipe\VACT

TASKBAR #7
Start
📝
💻
Vector Node AST Inspector Hover node to inspect
{
  "id": 6,
  "type": "TEXT_INPUT",
  "label": "Text Area",
  "bounds": [130, 150, 860, 470],
  "centroid": [560, 385],
  "interactable": true,
  "focused": true,
  "depth": 2,
  "parent_id": 1,
  "surface": "IDXGIOutputDuplication",
  "dt_ms": 18.2
}
Interactive Canvas

1-Bit Ordered Bayer Dither Matrix

Move your cursor across the canvas below to reveal the pixelated retro face beneath the ordered dither threshold.

HOVER TO BURN THRESHOLD VEIL
Kernel:
Palette:
Developer Integration

Verified Native SDKs

Official bindings connecting your agent decision loops directly to the local Win32 named pipe \\.\pipe\VACT.

sdks/typescript/example.ts
import { VactClient } from 'vact-sdk';

const client = new VactClient();
await client.connect();

// Hydrated AST state available synchronously at any time
const scene = client.getState();
console.log(`Active Window: ${scene.active_window}`);

// Reactive State Barrier: waits for window focus transition before dispatch
await client.waitForStateChange({
  predicate: (g) => g.active_window.includes('Notepad'),
  timeoutMs: 3000,
});

// Dispatch deterministic hardware click via sub-pixel centroid
await client.agent().click(6);
await client.agent().type(6, 'VACT Protocol Active');
Getting Started

Zero-Friction Local Execution

Run the daemon, check environment health, and launch an autonomous mission with a single command.

Step 1

Clone Repository & Verify Environment

Run the built-in diagnostic doctor to verify DXGI output duplication and WinRT dependencies.

git clone https://github.com/fy2ne/VACT.git && cd VACT
.\vact.cmd doctor
Step 2

Run Autonomous Agent Mission

The root launcher automatically boots vactd in the background if not running, then dispatches the mission.

.\vact.cmd --mission "Open Notepad and type VACT Protocol Active"
Step 3

Inspect Real-Time HUD Overlay (Optional)

Launch the transparent Minecraft F3+G sci-fi HUD matrix over your desktop to observe real-time bounding box segmentation.

cargo run -p vactd -- start --overlay
FEATURED ARTICLE

Why Desktop Agents Fail: The Architectural Limits of Vision-Language Models

fy2ne dissects why 2,000-token screenshot models bleed inference costs and latency, how accessibility tree scrapers get blinded by hardware-accelerated canvases, and how deterministic direct GPU compute pipelines eliminate coordinate hallucination.

Read fy2ne's Technical Manifesto ↗