Workspace/Lesson workspace
Loading progress
Acting & collaborating40 min

Produce a browser research trail that supports claims

Lesson 3 of 3
How to study this lesson

Read one section, trace the worked example, and try the knowledge check. Bookmark saves a shortcut; notes appear in My notebook. Mark lesson complete is your own assessment and does not mark its lab passed.

By the end, you can

  • Separate navigation evidence from claim evidence.
  • Track source identity, observation time, and support.
  • Evaluate research tasks with outcome and provenance checks.

Research is more than collecting tabs

A browser research agent should turn a question into explicit claims that require evidence. For a comparison of two developer tools, claims might concern supported transports, version compatibility, or documented limits. Opening ten pages is activity, not coverage. Create a claim ledger with question, source URL, page title, observed version, relevant evidence, and unresolved uncertainty. The final answer should distinguish what the sources establish from the agent's interpretation.

Browsing state and evidence state have different lifetimes. A tab can close while its verified evidence remains useful. A bookmarked URL can stay stable while the page content changes. Record the date of observation and, when allowed and useful, a short excerpt or content fingerprint. Preserve only the material needed for the claim and respect the source's access restrictions. A trace should be reviewable without becoming an indiscriminate archive.

Resolve URLs and page identities carefully

Search results provide candidates, not guaranteed support. Open the original source, check its title and version, and follow relevant documentation links. A redirected URL may point to a newer release than the one named in a query. Keep the resolved URL alongside the requested URL when that distinction affects interpretation. Official release notes, specifications, and primary papers are generally stronger support for implementation claims than an undated summary of another source.

Canonicalization is useful for deduplication but must preserve meaningful information. Removing a tracking parameter often helps; removing a version parameter may combine incompatible documentation. The simulation removes only a known tracking key and fragments, then groups evidence by canonical URL. That is a deliberate local rule, not a universal URL normalizer. Domain names alone are too coarse because different pages on one domain can support different claims.

Attach evidence at claim granularity

Suppose a page says a client supports streaming responses, and your draft says streaming responses survive reconnection without loss. The citation is related but insufficient: capability and delivery guarantee are different claims. Split the draft statement and look for evidence addressing reconnect behavior. If no source establishes it, mark the guarantee unresolved or describe it as a property your application must implement and test.

A useful evidence record contains a support type such as direct specification, observed behavior, or inference. Avoid a source count that treats these categories as equivalent. Three pages copying one announcement still provide one underlying evidence lineage. A browser agent can track provenance links and contradictions mechanically, while a human or model assesses meaning. The code below checks claim coverage and deduplication, leaving semantic entailment explicitly outside its capabilities.

Evaluate outcomes, not a preferred click sequence

WebArena introduced realistic web tasks with functional evaluation in controlled environments, making task outcomes a central concern. A research workflow needs similar outcome criteria: required questions answered, evidence attached, conflicts preserved, and unsupported claims excluded. [WebArena paper](https://arxiv.org/abs/2307.13854). There may be several valid navigation paths to the same evidence. Requiring a specific click sequence can punish a shorter correct path and reward a long but unproductive one.

Use stable fixture pages for repeatable evaluation and a separate set of live checks for changing documentation. Include redirects, inaccessible pages, conflicting versions, and a source that contains an injected instruction. The correct behavior on an inaccessible page is to report the gap and pursue another permitted source, not fabricate its contents. Separate browser failures from evidence failures so improvements can target the right part of the system.

Deliver an answer with practical limits

The final research artifact should make a decision easier to inspect. Lead with the supported finding, attach citations near the claims they support, and state relevant version or date constraints. For a technical comparison, a compact table can align each question with the two tools and the evidence gap. Do not bury a missing critical capability beneath a polished narrative or treat a simulation as a measured production result.

Maintain a stop rule: every required claim has adequate support, unresolved conflicts are explicit, and further browsing is unlikely to change the decision within the available budget. Stop rules prevent endless searching for redundant agreement. They also let you explain incompleteness honestly when the budget expires. A browser agent is valuable when its observations become traceable evidence, and when the executor's reliable interactions remain connected to the research question throughout the workflow.

Work through the code

This teaching simulation uses reserved example-domain URLs and an invented claim ledger. It removes one tracking parameter while preserving the version query, groups duplicate source references, and reports missing claims. It does not browse or verify semantic support.

m15_lesson3.py
python
from urllib.parse import urlsplit, urlunsplit, parse_qsl, urlencode

def canonical(url):
    parts = urlsplit(url)
    query = [(key, value) for key, value in parse_qsl(parts.query)
             if key != 'utm_source']
    return urlunsplit((parts.scheme, parts.netloc, parts.path,
                       urlencode(query), ''))

rows = [
    ('streaming', 'https://docs.example/spec?v=1&utm_source=a'),
    ('streaming', 'https://docs.example/spec?v=1#streaming'),
    ('authentication', 'https://docs.example/auth?v=1'),
]
ledger = {}
for claim, url in rows:
    ledger.setdefault(claim, set()).add(canonical(url))
required = {'streaming', 'authentication', 'reconnect'}
print('streaming sources:', len(ledger['streaming']))
print('missing:', ','.join(sorted(required - ledger.keys())))
print('version preserved:', canonical(rows[0][1]))
EXPECTED / ILLUSTRATIVE OUTPUT
streaming sources: 1
missing: reconnect
version preserved: https://docs.example/spec?v=1

Run Python snippets locally with the prerequisites named above. The module coding lab runs directly in your browser.

Pause and reason

Two sources confirm streaming and one source describes authentication. Your required comparison also asks about reconnect guarantees. What belongs in the final artifact?

Check your understanding

A source supports version 1, but your comparison concerns version 2. What is the most defensible treatment?

Your notes

Explain the mechanism in your own words. Add a failure you want to test.

Saved notes appear in your notebook

Go deeper with primary sources

Practice this module