Predicate turns the rendered web into semantic snapshots and verification signals, so agents act with bounded retries, lower token usage, and deterministic outcomes.
Structure-first snapshots reduce prompt load
Assertions gate success deterministically
Snapshot → action → assertion loop
The web was built for people, not agents. Predicate builds the runtime that converts rendered UI into structured snapshots, then verifies every step with explicit assertions so automation is predictable and testable.
Early agent stacks treated the web like pixels. That works for demos, but it breaks under scale: high token costs, ambiguous actions, and retries with no proof of success.
We found that reliability comes from structure and verification, not more images. So we rebuilt the stack around the rendered DOM, coarse pruning, and semantic snapshots that can be asserted against.
The result is a runtime that makes agent steps measurable: each action is followed by a snapshot and assertions that deterministically gate success or failure.
Predicate is an engineering-first company focused on agent runtime infrastructure. Our team blends distributed systems, browser internals, and applied ML to make automation predictable and debuggable.
We build core runtime components instead of wrappers. The goal is simple: make browser agents verifiable, token-efficient, and reliable in production.
Built by engineers who have shipped production automation. We focus on determinism, traceability, and runtime guarantees so systems are testable, not just functional.
Reliable pipelines for snapshot generation and trace delivery
Rendered DOM, layout stability, and actionability analysis
We build with production constraints in mind: observability, predictable latency, and clear failure modes.
Step-level assertions and traces that explain outcomes
Reliable agents depend on structured snapshots, not raw images. The runtime should expose the right elements and prove outcomes with assertions.
When a step fails, we want a clear signal and evidence—not blind retries. Deterministic verification makes automation trustworthy.
Agents should have a consistent loop: snapshot → action → assertion. This makes behavior measurable, debuggable, and safe to ship.
Teams use Predicate to make browser automation verifiable and stable. The focus is on traces, assertions, and lower token budgets—so failures are explainable.
A structure-first pipeline that turns the rendered DOM into verifiable agent steps
We render the page and remove obvious noise early. This keeps snapshots compact and token-efficient while preserving actionability.
The gateway refines candidate elements, assigns salience, and produces a semantic snapshot suitable for reasoning and assertions.
Each step is executed against the snapshot and then verified with explicit assertions. Success is gated; failures are traceable.
We favor explicit assertions and trace evidence over retries. This makes agent behavior observable and testable.
Coarse pruning and semantic snapshots reduce prompt size without losing critical state.
Clean responses, clear traces, and deterministic behaviors make debugging straightforward.
Predicate turns UI state into structured snapshots and verification signals that agents can trust.
Start with the SDK and see how structure-first snapshots reduce tokens and improve reliability.