Execution Intelligence for AI Agents

Browser infrastructure gives you a browser. Scrapers give you text. Predicate gives agents a grounded action space— visible, clickable elements with deterministic geometry and lightweight visual cues.

Note: This page compares action grounding (deciding what to click and where). Full browser execution is handled by an external runtime.

Browserbase

→ Infrastructure (cloud browsers)

Firecrawl

→ Data Extraction (text/markdown)

Predicate

→ Execution Intelligence (grounded action space)

Feature Comparison

Focus: what an agent can reliably use to choose actions (not marketing checkboxes).

Capability	Browserbase	Firecrawl	Predicate
Primary Use Case	Browser runtime	Read / RAG	Agent action grounding
Output an agent can act on	Screenshots / DOM	Markdown / JSON	Grounded action space
Element coordinates (x, y, w, h)	Not native	N/A	Yes
Visibility & occlusion awareness	Requires inference	Read-only	Explicit signals
Visual cues for action choice (e.g. is_primary)	Model-inferred	None	Computed
Determinism (same page → same grounding)	Varies by model	High (read-only)	High
Retries needed to choose a target	Often 1–3	N/A	Often 0
Integration surface	Browser + model	Scraper API	One grounding API
Best For	Execution runtime	Reading & extraction	Agents that must act

* “Not native” means achievable, but typically via a vision loop or additional glue code rather than a deterministic API response.

Benchmark Methodology

We benchmark the decision layer: how much cost and uncertainty it takes to identify the correct action target (what to click/type, and where). Full browser execution (navigation, JavaScript side effects, session state) is handled by an external runtime and is reported separately.

Test Cases

Link Click: example.com → click “Learn more”
Search Input: wikipedia.org → locate search box and submit
Commerce Flow: amazon.com → Best Sellers → PDP → Add to Cart (when accessible)

Metrics

Decision cost: tokens/credits per successful target selection
Retries per action: how many re-attempts before selecting a valid element
Misclick rate: wrong target selected (e.g., image instead of CTA)
Access reliability: block/throttle rate and tokens wasted on blocked pages
Determinism: same page snapshot → same grounded map

Fairness Notes

We report blocked pages explicitly (no stack can click “Add to Cart” if the page is throttled).
Predicate can simulate multi-step flows by chaining observations across pages; execution is optional.
Where execution is involved, we separate “grounding success” from “navigation success.”

Why browser infrastructure isn't enough

Browser infrastructure gives you a place to run a session, but agents still need a reliable way to choose actions. Vision-first loops often guess and retry. Predicate provides a grounded action space upfront: visible elements, deterministic geometry, and lightweight visual cues for action selection.

Why reading ≠ acting

Content extraction tools are excellent for reading, summarization, and RAG. But agents that must interact need more than text — they need to know what is clickable, what is visible, and where it is on the screen.

Why determinism matters for production agents

Production agents must be debuggable and reproducible. Deterministic grounding reduces retries, reduces cost variance, and makes failures explainable (blocked page, occlusion, ambiguity) instead of mysterious.

If you're building agents that must act, Predicate is the missing layer.

Try the Playground — Explore SDK Examples or Test the API Directly

Select Example:

Apply a permission policy, run agent steps with lifecycle hooks, trace tool calls, and verify a real download deterministically.

1# Verification-first runtime demo (Agent acts; Predicate asserts)
2from sentience import SentienceBrowser, PermissionPolicy, SentienceAgent
3from sentience.llm_provider import OpenAIProvider
4from sentience.agent_runtime import AgentRuntime
5from sentience.tools import ToolRegistry, ToolContext, register_default_tools
6from sentience.verification import exists, download_completed
7from sentience.tracing import Tracer, JsonlTraceSink
8
9# Tracing (local JSONL; upload optional)
10tracer = Tracer(run_id="demo-run", sink=JsonlTraceSink("trace.jsonl"))
11
12# Startup permission policy avoids non-DOM browser permission bubbles
13policy = PermissionPolicy(
14    default="clear",
15    auto_grant=["geolocation"],
16    geolocation={"latitude": 37.7749, "longitude": -122.4194},
17)
18
19browser = SentienceBrowser(
20    api_key="sk_live_...",
21    allowed_domains=["example.com"],
22    permission_policy=policy,
23)
24browser.start()
25
26llm = OpenAIProvider(api_key="sk_openai_...", model="gpt-4o-mini")
27agent = SentienceAgent(browser, llm, tracer=tracer)
28runtime = AgentRuntime(browser, browser.page, tracer)
29
30# Typed, traceable tools (includes evaluate_js + permission tools)
31registry = ToolRegistry()
32register_default_tools(registry, runtime)
33ctx = ToolContext(runtime)
34
35def on_start(ctx): print("hook start:", ctx.goal)
36def on_end(ctx): print("hook end:", ctx.success, ctx.outcome)
37
38browser.page.goto("https://example.com/billing")
39
40# Small introspection (bounded output; no DOM dump)
41title = await registry.execute("evaluate_js", {"code": "document.title"}, ctx=ctx)
42
43# Act with lifecycle hooks
44agent.act("Sign in if needed", on_step_start=on_start, on_step_end=on_end)
45
46# Verify + download (assert what happened, not what you hope happened)
47runtime.begin_step("Download invoice and verify")
48await runtime.snapshot(limit=60)
49runtime.assert_(exists("role=button text~'Download invoice'"), "has_download_button", required=True)
50
51agent.act("Click 'Download invoice PDF'", on_step_start=on_start, on_step_end=on_end)
52
53await runtime.snapshot()
54await runtime.check(download_completed("invoice"), label="invoice_downloaded", required=True).eventually(timeout_s=10)
55
56print("PASS ✓ invoice_downloaded")
57await tracer.close(upload=False)
58browser.close()

Verification Output

✓ Jest-Style Assertions

Verify outcomes deterministically — assert what happened, not what you hope happened

📸 Stability-Aware Snapshots

Rendered DOM after hydration with confidence scoring — enables deterministic verification

↻ Bounded Retries

Retry verification (not actions) with confidence gating — explainable failures with reason codes