Today we're launching the official Context.dev integration for Eve.
If you're building an AI agent with Eve, you can now give it reliable access to the live web with one registry command. The connection exposes 34 Context.dev tools for web search, scraping, crawling, structured extraction, document parsing, brand intelligence, screenshots, website monitoring, and large asynchronous batch jobs.
That means an Eve agent can move beyond reasoning over whatever happened to fit in its prompt. It can find current sources, read a JavaScript-rendered page, turn an entire site into clean Markdown, extract exactly the fields a workflow needs, watch those fields for changes, and bring the results back into a durable agent run.
No custom tool wrappers. No scraper fleet to maintain. No shared API key hard-coded into your agent.
Live web context for durable agents
Eve is Vercel's open-source, filesystem-first framework for building durable AI agents. An Eve project keeps an agent's instructions, tools, skills, channels, schedules, and connections in conventional files under agent/, making the system easy to inspect and extend.
Connections let those agents reach external services through protocols such as MCP. Context.dev is now a first-class entry in Eve's integrations registry, backed by our hosted MCP server at https://mcp.context.dev/mcp.
The fit is straightforward: Eve gives an agent a durable runtime, and Context.dev gives it fresh, structured knowledge from the web.
Without live context, an agent can only work from model knowledge, user-provided material, or data your team has already collected. That is enough for some tasks, but it breaks down quickly when the answer depends on what is true right now: a pricing page changed, a new product launched, documentation was updated, a job was posted, or a customer entered a domain that your application has never seen before.
You can solve that by assembling search providers, headless browsers, proxy infrastructure, HTML cleaners, schema extraction prompts, storage, schedulers, and diffing logic. Or you can connect Context.dev and let the agent choose the right purpose-built tool for the task.
Add Context.dev to an Eve agent
From an existing Eve project, run:
eve add connection/contextEve writes the initial connection under agent/connections/ and installs the authentication dependency when needed. The generated agent/connections/context.ts is intentionally small:
import { connect } from "@vercel/connect/eve";
import { defineMcpClientConnection } from "eve/connections";
export default defineMcpClientConnection({
url: "https://mcp.context.dev/mcp",
description:
"context.dev: search the live web, scrape and crawl sites, extract structured data, parse files, retrieve brand intelligence, monitor changes, and run batch jobs.",
auth: connect("context"),
});Then link the project, create the Vercel Connect connector, and pull the local OIDC environment:
vercel link
vercel connect create mcp.context.dev --name context
vercel env pullVercel Connect owns the OAuth flow. Before a person's first Context.dev tool call, they authorize access in their own browser. The agent definition stays clean while access remains tied to the end user making the request, which is especially useful when the same agent serves multiple people through web chat, Slack, or another channel.
Once connected, the tools are available to the agent through Eve's normal connection workflow. You describe the outcome in plain language; the agent can discover the relevant Context.dev capability and call it with structured inputs.
From one page to the whole live web
The integration gives Eve agents several levels of web access rather than forcing every task through one generic fetch operation.
When the agent knows the URL, web-scrape-markdown turns the page into clean, LLM-ready Markdown. It supports main-content filtering, links, images, selectors, PDF page ranges, dynamic-page waits, and browser actions. If the task needs the original DOM, attributes, or scripts, web-scrape-html returns the rendered HTML instead.
When the URL is unknown, web-search finds current sources and can scrape ranked results in the same call. For multi-page work, web-crawl follows relevant internal links and returns Markdown from across the site. If the agent only needs an inventory of URLs, web-scrape-sitemap discovers them without paying the cost of fetching every page body.
Those distinctions matter. A research agent should search when it needs to discover sources, scrape when it already has the right page, and crawl only when the answer spans a site. Giving the model explicit tools for each job helps it gather useful context without pulling unnecessary data into the conversation.
For large jobs, submit-batch moves the work out of the synchronous turn. An agent can submit as many as 25,000 URLs or start a large crawl, check progress, retrieve paginated results, and cancel or delete the job when asked. Long-running collection no longer has to block a chat request or depend on a fragile loop inside the model.
Extract answers, not just pages
Raw page content is useful, but production workflows often need a predictable object rather than several thousand tokens of prose.
With web-extract, an Eve agent can crawl the relevant parts of a website and return data shaped by a JSON Schema. You can ask for pricing tiers, office locations, open roles, security certifications, product details, or any other defined set of fields. The output is ready for application logic, a database record, or the next step in an agent workflow.
The connection can also parse files. parse-document converts PDFs, Office documents, spreadsheets, presentations, images, code, data files, and plain text into clean Markdown. An agent can therefore reason across a vendor's website and a proposal the user uploaded without your team maintaining separate document parsers for every format.
This opens up workflows like:
- A procurement agent that reads a vendor's current security pages, parses an uploaded contract, and produces a structured risk review
- A recruiting agent that extracts open roles and requirements from company career sites
- A sales research agent that collects pricing, positioning, customer stories, and recent product changes before a call
- A support agent that crawls the latest documentation instead of answering from an outdated index
Brand intelligence built into the agent
Context.dev began with brand intelligence, and those capabilities are available through the Eve connection too.
An agent can resolve a company from a domain, company name, work email, stock ticker, ISIN, transaction descriptor, or direct URL. The structured response can include logos, colors, descriptions, social profiles, links, industry, and location. For conversational experiences, get-brand can render that information as a visual brand card instead of returning raw JSON.
Other tools go deeper into how a company looks and where it fits. An agent can extract a site's style guide, identify its font families and usage, collect page imagery, capture a rendered screenshot, or classify the company with NAICS and SIC codes.
That makes the integration useful far beyond research. An onboarding agent can personalize a new workspace from a user's email domain. A design agent can inspect a brand before generating a customer-facing asset. A fintech agent can turn a messy transaction descriptor into a recognizable merchant. A CRM agent can enrich a sparse account record without sending the user to another screen.
Turn changes on the web into agent events
Sometimes the important question is not "what does this page say?" but "what changed since the last time we checked?"
The Context.dev connection includes the full Monitors workflow. An Eve agent can create a recurring monitor for a page, sitemap, or structured extraction target; inspect its configuration and run history; trigger an immediate check; and retrieve the complete evidence behind a detected change.
Page monitors catch exact content changes. Sitemap monitors identify added and removed URLs. Extract monitors track structured facts and distinguish meaningful changes from cosmetic edits. Results can include text diffs, semantic evidence, confidence, and importance, giving the agent enough context to decide what deserves attention.
Combine that with Eve schedules and channels, and useful patterns become simple to express:
- Check competitors' pricing every morning and post only material changes to Slack
- Watch a documentation sitemap and ask an agent to summarize newly published pages
- Monitor customer security pages and flag changes relevant to an internal review
- Track job listings across target accounts and update an opportunity brief when hiring priorities shift
The web becomes an ongoing input to the agent rather than a one-time lookup.
A more complete agent data layer
We built the Context.dev MCP server around the way agents actually work. They rarely need only a search result or only a scraped page. They need to discover the right source, retrieve it reliably, reduce it to useful context, structure the answer, and sometimes repeat the process later or across thousands of URLs.
The Eve integration makes that whole surface available through one authenticated connection. The agent gets focused tools with clear contracts, your application gets structured results, and your team gets to spend its time on the product behavior that makes the agent valuable.
Get started
Visit the Context.dev integration page in Eve, then add the connection to your project:
eve add connection/contextIf you're starting a new agent, you can create an Eve project with npx eve@latest init my-agent and add Context.dev from there.
We'd love to see what you build, whether it's a research agent that stays current, a monitoring workflow that catches the signal in website changes, or a product that becomes instantly useful as soon as a customer enters their domain.
Your agent already knows how to reason. Now it can know what's happening on the web.