The Problem

Public APIs expose only part of what users can do.

01

Incomplete Execution Coverage

Capabilities available through the interface are often missing from public APIs.

02

Fragmented Workflows

Work moves across messaging, approvals, CRM, ERP, and internal tools without one consistent execution layer.

03

Costly Integration

Point-to-point APIs and UI automation add implementation effort, maintenance, and runtime overhead.

Execution Paths

One Agent Task, Two Runtime Paths

Compare how a screen-oriented browser path renders, captures, interprets, and acts—then switch to Herbert Runtime to follow the same task through structured context and declared actions.

From Agent Request To Browser Action

Enter the prompt, follow the first LinkedIn frame through Chromium, then watch the browser-state loop continue through model inference and Playwright actions. The sequence is slowed for clarity; real latency varies.

Agentic AI Execution Agent Session

   .----.
  / o  o \
 |   --   |
  \ ____ /
   /|  |\

Claude Code-styleBrowser automation workspace model session~/browser-taskconfirm before publish Herbert A. SimonA tribute to his work on bounded rationality and satisficing.

User prompt: Prepare a Founding Engineer job posting on LinkedIn and Indeed. Complete the required fields, stop at any verification step, and do not publish either post.

[task]Task accepted · publishing disabled

[constraint]Create two drafts · do not publish
[state]Relevant application state prepared for the runtime
[request]Runtime request prepared from task constraints and application state
[render]AI-Native Rendering Engine · agent-facing context ready
[context]DCP · declared Save draft actions available
[action]LinkedIn · draft saved · not published
[action]Indeed · draft saved · not published
[result]Updated application state returned to the model

[plan] [plan]
[check] [result]
[check] [result]
[tool] [ready]

Preparing the prompt

Browser Session LinkedInIndeed

Herbert Runtime Structured Execution Result

The same task is handled through agent-facing context and declared application actions.

Steps 04–08 AI-Native Rendering Engine

Application state becomes model-readable context.

Steps 09–12 Declarative Context Provider (DCP)

Declared actions return updated application state.

LinkedInDraft pendingNot published

IndeedDraft pendingNot published

AI ModelWaiting for updated state

Application state → structured context → declared action → updated state

New Tab

DOM Tree + Computed Style HTMLCSS htmlbodynavmainsectionform Computed Style · main displaygrid grid-template1fr 1fr gap16px color#000 font-size16px Layout Fragments + Box Geometry x · y · width · height Display List + Paint Commands 01 DrawRect(header) 02 DrawText(title) 03 DrawImage(card) Layerization Paint Chunksheadercontentoverlay Layer Assignmentscrollingtransformoverlay Composited Layers Rasterization · Skia Paint RecordsDrawRectDrawTextDrawImage 2D GraphicsSkia Frame Aggregation + Draw

Waiting

Task Ready

The prompt will wait for Enter before the agent starts.

LinkedInSearchHomeMy NetworkJobs

JobsFind the right people for your team.Manage jobs and reach qualified candidates.

Create a LinkedIn job post Job title Company Workplace type Draft savedNot published

Work Email Verification Check your work email Enter the verification code to continue.

Blink Engine + JavaScript Engine

V8JavaScript / WebAssembly

DOM Tree + Computed Style html body nav main display: grid gap: 16px color: #000 Layout Fragments + Box Geometry x · y · width · height Display List + Paint Commands 01 DrawRect(header) 02 DrawText(title) 03 DrawImage(card)

Compositing Pipeline

GPUTexture Tiles · VRAM

Layerization Paint chunks are organized into layers. Rasterization · Skia Paint records are rasterized into tiles. Frame Aggregation + Draw

Simplified comparison of two agent execution paths. In the conventional path, observation payloads may include screenshots and DOM- or accessibility-derived structure; GPU acceleration, software rendering, and shared-memory behavior vary by platform. The Herbert view shows public component boundaries rather than internal implementation details. Sequence and pacing are staged for clarity. No job post is submitted. Herbert Computer is not affiliated with the services shown.

Architecture

What Changes Inside The Runtime

Herbert Runtime changes the agent-facing output path. The AI-Native Rendering Engine prepares model-readable context, while the Declarative Context Provider exposes executable application-level actions.

Technology 01

AI-Native Rendering Engine

Renders the parts of a web application an AI model needs as structured semantic data.

ComputeRemoves visual rendering work that is not required for agent execution.
TransferSends structured semantic data instead of full-screen image frames.
LatencyShortens the path from application state to model-readable context.

Technology 02

Declarative Context Provider

Provides a context-action layer that declares application context and executable high-level actions.

ContextPackages relevant application state into explicit, reusable context.
ActionsExposes higher-level operations instead of isolated UI interactions.
ExecutionReduces repeated inference, action, and verification cycles.

Compare The Runtime Layers Select any row. Its explanation opens directly below.

Shared Input Web Application

Shared Script Execution

V8 JavaScript & WebAssembly Engine · unchanged

Conventional Web Platform What Changes Herbert Runtime

Conventional Web Platform Chromium Rendering Pipeline Blink Rendering LifecycleDOM · Style · Layout · Paint Compositing PipelineLayerization · Rasterization · Skia Display CompositionCompositor Frames · GPU/Software Draw · Presentation Agent Output Path pixels → semantics Herbert Runtime Semantic Rendering application state → structured agent context

Rendering Pipeline

The conventional Chromium path produces paint records, rasterized tiles, and compositor frames for presentation. Herbert uses Semantic Rendering to provide structured context without requiring a presented screen frame as agent input.

Conventional Web Platform Rendered UI + Browser Automation screenshots · DOM inspection · low-level input Agent Interface input events → declared actions Herbert Runtime Declarative Context Provider structured context + executable application-level actions

Agent Interface

Instead of repeatedly interpreting rendered output and issuing low-level input events, agents receive structured context and executable actions from the runtime.

Conventional Web Platform GPU Rasterization & GPU Memory GPUTexture TilesGPU Memory / VRAM* CPU/software fallback when GPU acceleration is unavailable Output Resources raster frame → structured data Herbert Runtime Structured Data Output no screen-frame rasterization for agent context

Graphics Resources

With GPU acceleration, Chromium rasterizes and presents screen output using GPU resources and GPU memory. CPU and software paths remain available. Herbert’s agent output is structured data rather than a rasterized frame.

Shared Consumer AI Agent

Simplified Chromium-oriented rendering path. Process placement, rasterization, compositing, and hardware acceleration vary by platform and configuration. *VRAM refers to dedicated GPU memory; integrated GPUs may use shared system memory.

Benchmarks

Measured Across The Agent Execution Path

In a representative internal run of a multi-site job-posting workflow, Herbert Runtime reduced elapsed time, model-input tokens, and execution loops versus a Playwright MCP browser-automation baseline.

Workflow: Multi-site job-posting workflow
Agent Environment: Claude Cowork · Pro plan
Comparison: Playwright MCP (CDP) vs. Herbert Runtime
Local Hardware: 16-inch MacBook Pro · Apple M5 Max · 18-core CPU · 40-core GPU · 128GB unified memory · 8TB SSD
Measurement: End-to-end elapsed time · model-input tokens · execution loops
Report Type: Representative internal run · aggregate source values

Elapsed Time

18× Speedup End-to-end workflow completion

Playwright MCP 360 seconds

Herbert Runtime 20 seconds

Model Input

78% Fewer Tokens Tokens supplied during the workflow

Playwright MCP 12.6 thousand tokens

Herbert Runtime 2.8 thousand tokens

Execution Loops

35 → 1 Inference, action, and verification cycles

Playwright MCP 35 execution loops

Herbert Runtime 1 execution loop

Representative internal run using the same task, agent environment, and input conditions for both execution paths. Each chart uses its own scale. Run count, statistical distribution, software versions, and cache/network conditions were not included in the source summary. Results may vary by workload, model behavior, application state, runtime version, and system conditions.

Applications

Across Agentic Applications, Automation, And Data Workflows

Interactive Runtime Fit

Runtime For Agentic Applications

Herbert Runtime can sit beneath an agentic application as its web execution layer, providing structured context and executable actions across web interfaces.

Claude Cowork

AI-Native Execution Layer Herbert Runtime

Ready To Connect

Built By

Herbert Computer brings together Chromium maintainers, a W3C specification editor, AI and HCI researchers, and product builders with experience developing and operating browser runtimes across platforms.

Product: Herbert Runtime
Focus: AI-Native Web Execution
Expertise: Web Runtimes, AI Agents, HCI
Location: Seoul, Republic of Korea
Founded: 2025
Contact: in@herbert.computer

Team

Core Team

Alan, Ph.D.CEO
ZinoCTO
RussCPO
LeeSenior Engineer
KimSenior Engineer
BaeSenior Engineer
JiEngineer

Advisor

CheonProfessor, Syracuse University

AI-Native Runtime For The Web