Today we're launching the official Context.dev plugin for OpenClaw alongside a dedicated Context.dev agent skill.
If you run an agent with OpenClaw, you can now give it reliable access to the live web without building a search adapter, scraper, extraction pipeline, or monitoring system. The plugin adds Context.dev as a native provider for OpenClaw's web tools and exposes dedicated search and scrape tools. A hosted OAuth MCP connection opens the complete public Context.dev catalog.
The companion skill teaches the agent how to use that surface well: search when it needs to discover sources, scrape when it already knows the page, crawl when the answer spans a site, extract when the workflow needs typed data, and move large jobs into asynchronous batches.
Together, they turn live web context into a first-class part of an OpenClaw agent.
Live web context for an always-available agent
OpenClaw is an open-source, self-hosted gateway for personal AI agents. It connects one agent runtime to the messaging surfaces you already use, including Telegram, WhatsApp, Slack, Discord, Signal, iMessage, and WebChat, while keeping its workspace, sessions, memory, and tools under your control.
That makes fresh web context especially useful. An always-available agent should not be limited to model knowledge or pages someone manually pasted into a conversation. It should be able to answer questions whose facts changed this morning, inspect a link sent from a phone, track a site in the background, and bring a useful result back to the channel where the request began.
Context.dev gives it the data layer for that work. An OpenClaw agent can find current sources, render JavaScript-heavy pages, turn sites into clean Markdown, extract structured fields, parse documents, retrieve brand intelligence, capture screenshots, monitor changes, and process large collections of URLs.
No custom tool wrappers. No browser fleet to maintain. No prompt full of raw HTML.
Install the Context.dev plugin
Install the plugin from ClawHub and restart the OpenClaw Gateway:
openclaw plugins install clawhub:@contextdev/openclaw-context
openclaw gateway restartSet CONTEXT_API_KEY in the Gateway environment to use Context.dev as the provider behind OpenClaw's native web_search and web_fetch tools. The plugin also registers two explicit tools:
context_searchfinds current pages and returns normalized search resultscontext_scraperetrieves a known URL as clean Markdown or text
That native path covers the most common agent loop: discover the right page, retrieve its content, and continue reasoning with a compact result. Existing OpenClaw prompts and workflows can use the standard web tools, while agents that need to request Context.dev directly can choose the dedicated tools.
Connect the complete tool catalog with OAuth
Search and scraping are only the beginning. To give an OpenClaw agent access to the complete public Context.dev catalog, add our hosted MCP server:
openclaw mcp add context \
--url https://mcp.context.dev/mcp \
--transport streamable-http \
--auth oauth \
--parallel \
--connect-timeout 30 \
--timeout 180 \
--no-probe
openclaw mcp login contextThe login command starts the OAuth flow, so the agent can use Context.dev without putting a credential into its instructions or workspace files.
Once connected, the broader catalog gives the agent purpose-built operations for:
- Web search, Markdown scraping, rendered HTML, crawling, and sitemap discovery
- JSON Schema-based structured extraction from one page or an entire site
- PDF, Office document, spreadsheet, presentation, image, code, and text parsing
- Company logos, colors, descriptions, social profiles, industry data, and design systems
- Full-page screenshots of rendered websites
- Page, sitemap, and structured-data monitors with detailed change evidence
- Asynchronous batch jobs for large crawls and collections of independent URLs
Run openclaw mcp probe context after connecting to verify the server and see the tools available to the agent.
Give the agent the Context.dev skill
Tools describe what an agent can call. A skill gives it the operating judgment to choose the right call and use the result safely.
Install the Context.dev skill into the current OpenClaw workspace:
openclaw skills install @contextdev/context-devThe skill gives the agent a compact decision framework for the whole Context.dev surface. It prefers a direct scrape over a crawl for one known page, a sitemap over a crawl when only URLs are needed, and a batch only when the workload is actually large enough to benefit from asynchronous processing.
It also carries the less visible rules that make web workflows dependable. The agent is instructed to preserve source URLs, treat scraped content as untrusted data rather than instructions, validate extraction results against the requested schema, follow pagination when a complete collection is requested, and never invent missing brand assets or company attributes.
When the full MCP catalog is available, the skill tells the agent to inspect each tool's live input schema before constructing a call. When MCP is not connected, it can fall back to the Context.dev REST API and consult the current documentation instead of guessing fields or enum values.
From a chat message to a complete web workflow
OpenClaw agents live where requests happen. A message can arrive from a phone, a team channel, the Control UI, or an automated schedule. Context.dev lets that same agent gather and structure the web context it needs before replying.
For a quick research request, the agent can search for current sources, scrape the strongest results, and answer with links. If someone sends a specific product page, it can skip discovery and retrieve the rendered content directly. If the question spans a documentation site, the agent can discover its URLs or crawl only the relevant sections rather than forcing every task through one generic fetch.
For workflows that need predictable data, web-extract can return an object shaped by a JSON Schema. An agent can collect pricing tiers, open roles, office locations, product specifications, or security certifications and pass those fields into the next tool without first turning prose back into data.
That supports workflows such as:
- A morning briefing that searches for current developments, reads primary sources, and posts a cited summary to Slack
- A sales agent that enriches a company from its domain and prepares an on-brand account brief before a meeting
- A procurement agent that combines a vendor's live security pages with an uploaded contract or questionnaire
- A recruiting agent that extracts current roles and requirements from company career sites
- A research agent that submits a large URL set as a batch, checks progress later, and summarizes the completed results
The agent stays conversational, but the work behind the answer becomes structured and repeatable.
Turn website changes into agent events
OpenClaw already has schedules, channels, and an always-on Gateway. Context.dev Monitors adds the missing trigger: a meaningful change on the public web.
An agent can create a recurring page, sitemap, or extraction monitor, inspect its run history, trigger an immediate check, and retrieve the evidence behind a detected change. Page monitors catch exact content changes. Sitemap monitors identify added and removed URLs. Extract monitors track defined facts and separate meaningful changes from cosmetic edits.
Combine that with an OpenClaw schedule or channel and the agent can:
- Watch competitor pricing and report only material changes
- Detect new documentation pages and summarize what was published
- Track customer security pages and flag updates relevant to a review
- Monitor job listings across target accounts and refresh an opportunity brief
The agent does not have to rediscover the same pages or compare snapshots inside its context window. Context.dev handles the recurring collection and change evidence; OpenClaw decides what to do with the signal and where to send it.
A complete web data layer for OpenClaw
We built the Context.dev plugin around OpenClaw's native extension points. Simple requests can stay simple through web_search, web_fetch, context_search, and context_scrape. Deeper workflows can use the OAuth MCP connection for extraction, parsing, brand intelligence, monitors, screenshots, and batches. The skill sits across both paths and helps the agent choose the narrowest reliable operation.
That means you can start with one search and grow into a continuous web workflow without replacing the integration or maintaining another stack.
Get started
Install the Context.dev plugin from ClawHub:
openclaw plugins install clawhub:@contextdev/openclaw-contextThen add the Context.dev skill:
openclaw skills install @contextdev/context-devConnect https://mcp.context.dev/mcp when you want the complete catalog, and visit the Context.dev documentation for the API reference.
Your OpenClaw agent already has a place to think, remember, and act. Now it can work with what is happening on the web right now.