# OpenSEO Updates and Roadmap: Latest MCP Tools, Crawler Architecture, and 2026 Milestones

> Explore OpenSEO's latest updates including zero-credit project creation with MCP tools and a roadmap guiding in-house crawling and telemetry features through 2026. Get the latest on crawler architecture.

- Repository: [Every App/open-seo](https://github.com/every-app/open-seo)
- Tags: roadmap
- Published: 2026-07-26

---

**OpenSEO v0.1.2 introduces zero-credit project creation via MCP tools, per-call localization for SERP data, and a public roadmap prioritizing in-house crawling and telemetry-driven feature releases through 2026.**

OpenSEO is a modern, open-source SEO platform that combines a self-hosted backend with a cloud-native MCP (Machine-Control-Protocol) API designed for AI agents. Understanding the latest open-seo updates and roadmap helps developers integrate automated SEO workflows while avoiding vendor lock-in. This guide covers the recent v0.1.2 release, architectural decisions, and the phased development schedule documented in the source repository.

## Latest OpenSEO Releases

The project follows an incremental release cycle with detailed changelogs stored in `release-notes/`.

### v0.1.2 (July 2026)

Version 0.1.2 expands MCP capabilities and fixes critical UI issues:

- **`create_project` MCP tool** – Allows zero-credit project creation by writing project metadata (name, domain, market) directly without invoking DataForSEO. Implementation resides in [`src/server/mcp/tools/create-project.ts`](https://github.com/every-app/open-seo/blob/main/src/server/mcp/tools/create-project.ts).
- **Localized SERP queries** – Per-call `locationCode` and `languageCode` selection for `ranked-keywords` and `serp-competitor` tools.
- **UI hardening** – Fixes for search tab switching, rank-tracking loading states, and month-based Google Search Console date ranges.

### v0.1.1

Addresses deployment failures for self-hosted Cloudflare Workers installations, stabilizing the Wrangler deploy pipeline.

### v0.0.9 through v0.0.28

Incremental improvements to rank-tracking algorithms, keyword data routing, Google Search Console integration, and DataForSEO credit metering.

## MCP Architecture and Core Components

OpenSEO exposes functionality through typed MCP tools rather than traditional REST endpoints, enabling direct AI agent integration.

### Machine-Control-Protocol (MCP) Layer

The MCP layer exposes versioned tools that agents like Claude or Hermes consume. Key implementations include:

- [`src/server/mcp/tools/create-project.ts`](https://github.com/every-app/open-seo/blob/main/src/server/mcp/tools/create-project.ts) – Project instantiation without external API costs.
- [`src/server/mcp/tools/update-project-context.ts`](https://github.com/every-app/open-seo/blob/main/src/server/mcp/tools/update-project-context.ts) – Versioned context mutation.
- [`src/server/mcp/formatters.ts`](https://github.com/every-app/open-seo/blob/main/src/server/mcp/formatters.ts) – Response standardization.
- [`src/server/mcp/urls.ts`](https://github.com/every-app/open-seo/blob/main/src/server/mcp/urls.ts) – Route definitions.

### Onboarding Agent

The onboarding flow generates initial SEO strategy by scraping the target domain, calling DataForSEO for baseline data, and synthesizing Markdown recommendations via OpenRouter. The implementation spans:

- [`src/routes/api/onboarding/chat.ts`](https://github.com/every-app/open-seo/blob/main/src/routes/api/onboarding/chat.ts) – Streaming chat endpoint using TanStack AI SDK.
- [`specs/0006-onboarding-agent-implementation.md`](https://github.com/every-app/open-seo/blob/main/specs/0006-onboarding-agent-implementation.md) – Design specification for the seed function.

### Project Context Store

Rather than relational updates, OpenSEO uses immutable storage:

- **R2 buckets** store Markdown strategy blobs.
- **D1 table** `project_context_versions` maintains an append-only log of changes, enabling instant rollbacks.
- **Zero-downtime migrations** – The append-only schema avoids destructive alterations.

### Self-Hosting Infrastructure

Users deploy OpenSEO via Docker (local development) or Cloudflare Workers (production). Both configurations require a user-supplied DataForSEO API key, with architecture documented in:

- [`docs/SELF_HOSTING_DOCKER.md`](https://github.com/every-app/open-seo/blob/main/docs/SELF_HOSTING_DOCKER.md)
- [`docs/SELF_HOSTING_CLOUDFLARE.md`](https://github.com/every-app/open-seo/blob/main/docs/SELF_HOSTING_CLOUDFLARE.md)

### Crawling Strategy

The platform employs a hybrid crawling approach to minimize vendor costs:

- **In-house Workers crawler** – Default engine using `OpenSEOBot/1.0` user-agent, handling polite crawling and allow-list validation.
- **DataForSEO OnPage** – Optional off-load for JavaScript-heavy pages (incurring per-page fees).
- **Future local Playwright** – Planned `npx` CLI agent for private crawling, explicitly deferring full JS rendering until Cloudflare Browser Rendering integration is justified.

Documentation in [`docs/site-audit-pm-research.md`](https://github.com/every-app/open-seo/blob/main/docs/site-audit-pm-research.md) details block-detection telemetry and politeness algorithms.

## OpenSEO Roadmap: 2026 Development Schedule

The roadmap documented in [`docs/site-audit-pm-research.md`](https://github.com/every-app/open-seo/blob/main/docs/site-audit-pm-research.md) follows an 8-week sprint cadence leading into Phase 1 and Phase 2 milestones.

### Weeks 1–4: Foundation and Persistence

- **Week 1** – Schema additions for `audit_pages`, `audit_links`, and `audit_issues`. Implementation of block detection with honest "we were blocked" messaging and telemetry collection. Validation of `OpenSEOBot/1.0` allow-list handling across Cloudflare Free/Pro and Vercel.
- **Weeks 2–4** – Persistence refactor for SSR compatibility. Crawler hardening for redirect chains, politeness delays, and sitemap seeding. Initial issue engine with multipage SQL checks for duplicate content and broken links.

### Weeks 4–8: UI and Export Features

- **Weeks 4–6** – Issue severity UI, CSV export functionality, and MCP audit tools returning `how_to_fix` payloads. Google Search Console verified allow-list fix flow integrated into onboarding.
- **Weeks 6–8** – Client-side rendering (CSR) detection and disclosure in reports. Pricing posture definition including free tier TTL and data retention policies. Final security hardening buffer.

### Weeks 8–14 (Phase 1)

Scheduled audits with delta comparisons, AI-generated accessibility reports, thin-content detection, and depth analysis. Optional Cloudflare Verified-Bots filing for improved crawl rates.

### Phase 2 (Later 2026)

- **`npx` local agent** – New ingest endpoint for Playwright-based local crawling.
- **Cloudflare Browser Rendering** – JS execution for SPAs (cost-dependent).
- **R2 snapshot storage** – Historical HTML retention.
- **Advanced checks** – Hreflang validation and structured data verification.

The roadmap explicitly excludes full JavaScript rendering from Phase 1 to maintain cost control and leverage telemetry data for justification.

## Implementation Examples

### Creating a Zero-Credit Project via MCP

```typescript
import { createProjectTool } from "@/server/mcp/tools/create-project";

const result = await createProjectTool.handler(
  {
    name: "E-commerce Audit",
    domain: "example.com",
    locationCode: 2840,  // United States
    languageCode: "en",
  },
  extraAuthContext
);

console.log(result.structuredContent.project.id);  // UUID for subsequent calls

```

This bypasses DataForSEO credit consumption by writing directly to the D1 project registry and R2 context store.

### Streaming Onboarding Chat

```typescript
import { useChat } from "@tanstack/react-query-ai";

const chat = useChat({
  api: "/api/onboarding/chat",
});

// Streams OpenRouter responses while persisting versions to R2
await chat.sendMessage("Create a technical SEO strategy for my SaaS landing page.");

```

The endpoint [`src/routes/api/onboarding/chat.ts`](https://github.com/every-app/open-seo/blob/main/src/routes/api/onboarding/chat.ts) handles LLM communication and triggers `update_project_context` MCP tools automatically.

### Versioned Context Updates

```typescript
import { updateProjectContextTool } from "@/server/mcp/tools/update-project-context";

await updateProjectContextTool.handler(
  {
    projectId: "proj_abc123",
    markdown: "## Priority 1: Fix canonical tags\n...",

    note: "Added canonical recommendations from crawl",
  },
  extraAuth
);

```

Each call appends to `project_context_versions` in D1 while storing the full Markdown blob in R2, preserving history without mutation.

## Summary

- **OpenSEO v0.1.2** adds zero-credit project creation and localized MCP tools while hardening the UI.
- The **MCP architecture** in `src/server/mcp/tools/` exposes SEO functions to AI agents via typed, versioned contracts.
- **Self-hosting** supports both Docker and Cloudflare Workers, requiring only a DataForSEO key for external data.
- The **2026 roadmap** prioritizes in-house crawling through Week 8, defers JavaScript rendering to Phase 2, and emphasizes cost control via telemetry-driven decisions.
- **Immutable context storage** using R2 and append-only D1 logs enables rollback capabilities for SEO strategy iterations.

## Frequently Asked Questions

### What is the MCP API in OpenSEO?

The **Machine-Control-Protocol (MCP) API** is a typed interface exposed in `src/server/mcp/tools/` that allows AI agents to invoke SEO functions like `create_project`, `update_project_context`, and audit workflows. Unlike REST, MCP supports structured tool definitions that LLMs can discover and call autonomously, enabling automated SEO workflows without custom integration code.

### Can I self-host OpenSEO without using DataForSEO?

Partially. The core platform—including the MCP server, onboarding agent, and in-house crawler—runs entirely on your infrastructure using Docker or Cloudflare Workers. However, keyword data, SERP results, and certain audit features still route through DataForSEO, which requires an API key. The roadmap includes an `npx` local agent (Phase 2) to reduce dependency on external crawling services.

### How does OpenSEO handle cost control for large-scale crawling?

OpenSEO defaults to an **in-house Workers-based crawler** using the `OpenSEOBot/1.0` user-agent to avoid DataForSEO's per-page fees. The roadmap explicitly defers full JavaScript rendering (which requires expensive browser infrastructure) until telemetry justifies the cost. Block-rate metrics and crawl success telemetry in [`docs/site-audit-pm-research.md`](https://github.com/every-app/open-seo/blob/main/docs/site-audit-pm-research.md) drive decisions about when to enable advanced features.

### What is the difference between Phase 1 and Phase 2 in the roadmap?

**Phase 1 (Weeks 8–14)** focuses on scheduled audits, delta reporting, accessibility AI analysis, and thin-content detection using the existing HTML-only crawler. **Phase 2** introduces JavaScript rendering via Cloudflare Browser Rendering, local Playwright agents via `npx`, and advanced checks like hreflang validation. The phased approach ensures the free tier remains sustainable while gathering usage data to prioritize expensive features.