AI and agents

Validation your agent can call.

Agentic buying is arriving faster than the guardrails around it. An agent that assembles a campaign, rewrites a creative, or negotiates a deal needs to check its own work against the spec while it works, not after a human opens a validator UI. Every tool in the suite ships a Model Context Protocol server for exactly that: 19 callable tools, structured findings, no account.

Findings come back as structured JSON: a stable rule id, a severity, the line it came from, and fix guidance. An agent can act on that. It cannot act on a screenshot of a validator UI. Each server links to its source.

Why it matters

An agent cannot act on a screenshot.

The reason these are MCP servers and not web forms is the output contract. A validator UI returns pixels. An MCP tool returns a stable rule id, a severity, a location, and fix guidance, which is something a model can branch on, retry against, and cite back to a human.

Close the loop before spend

An agent that generates a VAST tag can validate it, read the failing rule, apply the documented fix, and re-validate, all before the creative reaches a player. The failure never becomes an impression.

Deterministic, not judged

These tools do not ask a model whether a tag looks right. They run the same Rust engine the CLI runs and return a verdict that is reproducible across runs. The model decides what to do, not what is true.

Auditable by a human

Every rule id maps to a published spec section. When an agent rejects a partner’s payload, the reason is a citation someone can take to that partner, not a model’s opinion.

The servers

Three servers, 19 tools.

VASTlint and RTBlint are hosted over HTTP: point a client at the URL and you are done. Pixellint runs locally over stdio while it is still early.

RTBlint

3 tools

https://rtblint.org/mcp

validate_bid_requestvalidate_bid_responselist_openrtb_versions

Validates OpenRTB bid requests and bid responses against versioned IAB spec snapshots. More

VASTlint

14 tools

https://vastlint.org/mcp

validate_vastvalidate_vast_urlfix_vastlist_rulesexplain_ruleget_adcp_capabilitieslist_content_standardscreate_content_standardsget_content_standardsupdate_content_standardsdelete_content_standardslist_creativescalibrate_contentvalidate_content_delivery

Validates, inspects, and repairs VAST ad tags, including wrapper chains, SIMID, VMAP, and DAAST. More

Pixellint

2 tools

stdio · local binary

validate_artifactlist_rulepacks

Validates impression pixels, click trackers, and conversion postbacks against vendor-documented rulepacks. More

Setup

Wiring it up.

The hosted servers need no install, no key, and no account. Add them to any MCP client that speaks streamable HTTP.

Claude Code, Claude Desktop, Cursor

{
  "mcpServers": {
    "vastlint":  { "type": "http", "url": "https://vastlint.org/mcp" },
    "rtblint":   { "type": "http", "url": "https://rtblint.org/mcp" },
    "pixellint": { "command": "pixellint-mcp" }
  }
}

Claude Code, one line each

claude mcp add --transport http vastlint https://vastlint.org/mcp
claude mcp add --transport http rtblint  https://rtblint.org/mcp
cargo install pixellint && claude mcp add pixellint pixellint-mcp

Then ask for what you want

> validate this VAST tag and fix whatever is deterministic
> does this bid request conform to openrtb 2.6-202505?
> check every pixel in this tag manager export for unhashed PII

AdCP

Governance for agentic pipelines.

The Ad Context Protocol defines how agents discover each other’s capabilities and transact advertising. VASTlint implements the governance side of AdCP 3.0, so an autonomous creative pipeline can declare and enforce content standards rather than hoping for the best.

Capability discovery

A calling agent asks what this agent can evaluate before it sends anything. get_adcp_capabilities returns the AdCP major versions supported, the protocols implemented, and the specialisms on offer.

Content standards

Create a policy, calibrate a creative against it before flight, then verify what was actually delivered met it. Tool calls are idempotent with replay protection, so a retry in an agent loop does not double-apply.