Skip to main content
Glama
Render MCP Server

Render MCP Server

by meiti-dev

@meiti/render

Render testing built for AI agents, not for people.

Today an agent tests a screen like a person would: take a screenshot, send it to a vision model, guess where to click, take another screenshot. It is slow, expensive and fragile. @meiti/render gives the agent what it actually needs:

  • A map of the screen instead of a picture. Every element that matters, with its role, name, text, value, state and position, as text. It takes a few milliseconds and any model can read it.

  • Actions by intent instead of coordinates. fill "Email" with ..., click "Save". The element is found by its role, label or visible text. If it is not there, the answer says what is.

  • Seeing by comparing maps. Act, scan, compare with the previous map: what appeared, what disappeared, what changed, what moved. "Nothing changed" is information too: a button that does nothing.

  • What a screenshot never shows. The requests sent to the server and their status, page errors, native dialogs.

  • Visual issues measured exactly, no vision model needed. Horizontal overflow, cut text, covered or off-screen elements, small touch targets, low contrast, broken images, buttons without a name.

  • Before and after. Compare two versions of an app (home page plus up to 3 linked pages, phone and desktop): worse, better or the same.

It works with apps that render inside same-origin iframes and waits until the screen is stable (two identical maps in a row and nothing loading) before reading it.

Use it from an agent (MCP)

npx -y @meiti/render

Add it to any MCP client as a stdio server with the command npx -y @meiti/render. It needs Node 18 or newer and a Chrome: the one puppeteer downloads, otherwise the Chrome installed on the machine, or the executable you set in MEITI_RENDER_CHROME.

Tools:

Tool

What it does

render_open

Opens a URL (any size: 375 for a phone) and returns the map and its visual issues.

render_act

One action by intent (click, fill, select, check, key, goto) and what changed.

render_expect

Checks what you expect: yes or no, with the exact proof.

render_scan

Scans the current screen again.

render_compare

Compares two versions of the same app.

render_close

Closes a session.

Example of what the agent reads after render_act {"type": "click", "target": "Add"}:

Acted on button:Add in 858 ms.
What changed: appeared 1: listitem:Milk; moved 4
Requests:
- POST http://localhost:3000/api/items → 201
Page errors: none

Related MCP server: kogiQA MCP Web Browser

Use it from code

import puppeteer from 'puppeteer';
import { SesionRender } from '@meiti/render';

const browser = await puppeteer.launch();
const session = await SesionRender.abrir(browser, 'http://localhost:3000', { ancho: 375, alto: 812 });
await session.hacer({ tipo: 'llenar', objetivo: 'Email', valor: 'ana@example.com' });
const result = await session.hacer({ tipo: 'clic', objetivo: 'Save' });
console.log(result.cambio.resumen);
console.log(session.verificar([{ pedido: { metodo: 'POST', url_contiene: '/api/users', status: 201 } }]));

Verified by Healer

@meiti/render is a MEITI tool, verified by Healer with exams that have known answers, run on every version:

Exam

Result

Visual issues (one planted issue per page, plus clean pages)

11 of 11, 0 false alarms, ~4 ms per scan

Actions and expectations (JavaScript error, silent 500, missing button)

10 of 10

Apps rendered in iframes, loading states, native dialogs

7 of 7

Before and after (worse, better, same)

3 of 3

License

MIT

Available Tools

6 tools
render_actA

Do one action by INTENT (no coordinates) and return what changed on the screen: elements that appeared, disappeared, changed or moved (or "nothing changed": a control that does nothing), requests to the server with their status, page errors and native dialogs (accepted automatically). target is an id from the map (like "button:Save"), a label or a visible text; if it is not on the screen, the answer lists what is there.

Inputs: action (required), session (required), include_map.

render_closeC

Close a session.

Inputs: session (required).

render_compareA

Compare two versions of the same app (for example before and after a change): the home page and up to 3 pages it links to, on a phone and a desktop. Says WORSE if a visual issue appears, an interactive element disappears or a page stops opening; BETTER if issues were fixed; SAME otherwise.

Inputs: url_after (required), url_before (required).

render_expectA

Check what you expect against the current screen and the last action; each answer is yes or no with its proof (the exact element or request). Expectations: {"exists": "..."}, {"not_exists": "..."}, {"text": "...", "contains": "..."}, {"appeared": "..."}, {"disappeared": "..."}, {"no_changes": true}, {"no_issues": true | ["contraste", ...]}, {"no_errors": true}, {"request": {"method": "POST", "url_contains": "/api/x", "status": 201}}.

Inputs: session (required), expectations (required).

render_openA

Open a page in a real browser and return its MAP: every element that matters (role, name, text, value, state, position) plus visual issues measured exactly (horizontal overflow, cut text, covered or off-screen elements, small touch targets, low contrast, broken images, unnamed buttons). Works inside same-origin iframes. Returns a session id for render_act, render_expect and render_scan.

Inputs: url (required), width, height.

render_scanB

Scan the current screen again (waits until it is stable) and return the full map with its visual issues.

Inputs: session (required).

Tool Schema Changelog

Recent tool additions, removals, and schema changes observed during successful MCP inspections.

Loading tool schema changelog…

    TDQS

    A3.6/5.0

    Scored across 6 tools

    Disambiguation4/5

    Each tool has a mostly distinct role: open, act, expect, scan, compare, close. There is some conceptual overlap between render_open and render_scan (both return a map) and between render_act and render_expect (both report changes/no-changes), but the descriptions make the intended usage clear enough to avoid most misselection.

    Naming Consistency5/5

    All six tools follow the same predictable render_verb pattern in snake_case: render_open, render_act, render_expect, render_scan, render_compare, render_close. No naming inconsistencies or mixed conventions are present.

    Tool Count5/5

    Six tools is well-scoped for a browser automation and visual verification server. Each tool covers a distinct phase of the workflow, and no tool feels redundant or missing at the count level.

    Completeness4/5

    The surface covers the core lifecycle: open a page, act, check expectations, rescan, compare versions, and close the session. Minor gaps exist around explicit navigation/reload or session listing, but agents can work around those using render_open and render_act.

    Maintenance

    ActivityMaintained
    ResponsivenessNo recent community issues

    Related MCP Connectors

    Related MCP Servers

    • A
      license
      Not graded
      quality
      A
      maintenance
      Enables an AI agent to measure live web and responsive UIs across mobile and desktop sessions, returning contrast ratios, touch-target sizes, overflow, clipping, and theme-drift problems as precise text findings tied to selectors instead of screenshots to guess from. Agents can also navigate, tap, type, scroll, switch device profiles and themes, and read the notes a human pins in the shared panel alongside the exact frame being viewed.
      95 npm
      MIT
    • A
      license
      Not graded
      quality
      A
      maintenance
      Enables AI agents to inspect live web and responsive UIs across mobile and desktop sessions, returning measured text findings on contrast ratios, touch-target sizes, overflow, and theme drift instead of screenshot guesses. It also lets a human and the agent share one live panel, so the agent can navigate, tap, and type while reading the user's pinned notes and frames.
      95 npm
      MIT