Render MCP Server
# @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)
```bash
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
```
## Use it from code
```js
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](https://meiti.dev/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
TDQS
Scored across 6 tools
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.
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.
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.
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.