# Greenroom: a second agent checks your agent's work
> Greenroom boots your app in a fresh machine, clicks through it like a person, and shows you what it saw before you merge.
This is the text version of https://trygreenroom.dev/, with the same content as the page. Hosted Greenroom checks web apps today and is open by invitation: join the waitlist at https://trygreenroom.dev/waitlist.
Under the headline is one picture of the product, drawn as a window: a real Greenroom run of Tallyboard, on our own machine. Tallyboard is our sample app (the checkout page of a made-up team product: a plan, a payment method and an order summary with a promo code, a total and a Pay button, on Node's standard library), and we planted the bug the run catches. The app's screens in it were captured again at a higher resolution, from the same app and the same steps.
It has two parts. On the left is the machine's browser at localhost:3000, as the recording shows it at step 7: the app's plan, payment method and order summary, with two places marked: the page says "SAVE20 applied: 20% off", and Total due today and the Pay button still read $240.00. Under it is a line of 7 ticks, one for each of the verifier's steps (step 4 opens localhost:3000, step 5 types SAVE20 into Promo code, step 6 presses Apply, step 7 reads the page, step 8 types NOPE into Promo code, step 9 presses Apply, step 10 reads the page); step 7 is lit. When the picture is first in view the run plays once by itself, from its first step: a pointer goes to where the verifier pressed, each check is filled in once the last step it cites has been shown, the verdict comes last, and it comes to rest on this picture. A Replay button plays it again; with reduced motion nothing plays until Play is pressed. Each tick, and each step number a check cites, shows its own frame when pressed.
On the right is the verifier's column for run `20261119-040708-bfc39badfe87a6cc`: "Verdict: fail", "3 of 4 checks passed, 1 failed.", and its checks as it wrote them:
- **Pass: Checkout page loads at localhost:3000.** Observed: Page loads with Order summary, Promo code box and Apply. (cites step 4 of the recording)
- **Fail: After applying SAVE20 without reload: summary says SAVE20 applied: 20% off, Discount -$48.00, Total $192.00, button Pay $192.00.** Observed: Message reads 'SAVE20 applied: 20% off' and Discount reads -$48.00, but Total due today reads $240.00 and the button reads Pay $240.00, not $192.00. (cites step 7 of the recording)
- **Pass: NOPE shows That code is not valid and amounts stay unchanged.** Observed: NOPE gives 400 and 'That code is not valid'; Total and Pay stay $240.00. The Discount line kept the earlier SAVE20 value of -$48.00. (cites step 10 of the recording)
- **Pass: Typing in promo box does not move layout.** Observed: The promo box was checked and nothing moved. (cites step 11 of the recording)
In the verifier's words: After applying SAVE20, the Discount shows -$48.00 but Total due today and the Pay button stay at $240.00 (steps 6, 7). The cause is that the total and the button are not updated after Apply. NOPE shows "That code is not valid" with the amounts unchanged (step 10). The run finished unverified.
## Tried before it is trusted.
Three cards, each a small drawing above a name and a line:
- **A fresh machine for every run.** Your app boots from one file. The machine is deleted afterwards. The drawing is a machine's window with a start mark in it, and the outlines of earlier machines behind it.
- **A second agent tries the app.** The verifier writes its own checks, then presses, types and reads. The drawing is an app's window with two agents beside it: one in grey, joined to it by a dashed line, and the verifier in mint, joined by a solid line, with its press marked on a button.
- **Evidence for the pull request.** Every check cites the steps of the recording behind it. The drawing is a sheet with three ticked rows, each joined to a numbered step.
## One run, from claim to verdict.
Your agent starts a run. Greenroom answers with a verdict. The page shows four steps on one line, each with a small panel of the first run above it, in the run's own words: the coding agent's task, three parts of the machine's boot, what the verifier did at steps 5 to 7, and the verdict:
1. **Claim.** The coding agent says what should work. Its task in this run says why: "A team upgrading with a promo code should see the price they will pay before they press Pay." And what should be seen: "The order is Team, 8 seats, $240.00. Type SAVE20 into Promo code and press Apply. Without reloading the page: the summary says SAVE20 applied: 20% off, the Discount line reads -$48.00, Total due today reads $192.00 and the button reads Pay $192.00. A code that does not exist, such as NOPE, shows That code is not valid and changes no amount."
2. **Boot.** The app starts in a new machine: a fresh machine made from your image; your repository copied into it; your start command run until the app answers.
3. **Check.** The verifier uses it like a person. In this run, at steps 5 to 7: types SAVE20 into Promo code, presses Apply, reads the page.
4. **Verdict.** Pass or fail, citing the steps. In this run: fail, and the page quotes the start of the verifier's words: "After applying SAVE20, the Discount shows -$48.00 but Total due today and the Pay button stay at $240.00 (steps 6, 7)."
## Written for the pull request.
After the fix, a second run passed. This is its report. It lists each check, its result and the step that proves it.
The fix: the Apply handler also calls showTotal, which rewrites Total due today and the Pay button. The second run is `20261119-041056-305df27f9e4b95f3`. Its report, as Greenroom wrote it (its links point at our local daemon and are left out; the page shows the same rows without the kind after each check's name and the tool after each step):
> ### Greenroom: Verified
>
> **5 of 5 checks passed.** Verdict pass (message 14), accepted by coder. Finished 2026-11-19 04:14 UTC.
>
> Every listed check was observed on this build. That is the whole claim: it does not say the change works beyond these checks.
>
> | Result | Check | Evidence |
> | --- | --- | --- |
> | **PASS** | **launch** (value)
Checkout page loads at localhost:3000 | step 4 (navigate) |
> | **PASS** | **apply** (value)
After SAVE20 Apply without reload: message SAVE20 applied: 20% off, Discount -$48.00, Total due today $192.00, button Pay $192.00 | step 10 (snapshot) |
> | **PASS** | **nope** (value)
NOPE shows That code is not valid and amounts stay unchanged | step 8 (snapshot) |
> | **PASS** | **typing** (visual)
Typing in Promo code never moves layout | step 11 (typing_check) |
> | **PASS** | **sec** (value)
security_check reports no fail | step 12 (security_check) |
>
> **Run:** `20261119-041056-305df27f9e4b95f3`, 70 steps, created 2026-11-19 04:10 UTC, machine destroyed 2026-11-19 04:14 UTC
>
> Made by Greenroom. A check passes only on evidence the verifier observed; the coding agent's claims are not evidence.
## One file starts your app.
A start command and the address to wait for. A harness is a short file in your repo; this one booted both runs.
`.greenroom/harness.yaml`, the file both runs booted from:
```yaml
version: 1
# Tallyboard checkout: one page and a small server on Node's standard library, with nothing to install.
start:
command: node server.js
ready: http://localhost:3000/
timeoutSeconds: 30
# Ben is the second person the security check signs in as. Nothing under /api is public.
security:
users:
- name: ben
headers:
Cookie: session=ben-demo-session
```
How a harness gets made: https://trygreenroom.dev/harness (in words: https://trygreenroom.dev/harness.md).
## Add one line to your agent.
An MCP server. Invited teams sign in with Google. Once your team is invited, add the server to your agent.
The setup line for each agent:
Claude Code, in a terminal:
```sh
claude mcp add --transport http greenroom https://app.trygreenroom.dev/mcp
```
Codex, in `~/.codex/config.toml`:
```toml
[mcp_servers.greenroom]
url = "https://app.trygreenroom.dev/mcp"
```
Gemini CLI, in a terminal:
```sh
gemini mcp add --transport http greenroom https://app.trygreenroom.dev/mcp
```
Cursor, in `.cursor/mcp.json`:
```json
{ "mcpServers": { "greenroom": { "url": "https://app.trygreenroom.dev/mcp" } } }
```
GitHub Copilot, in `.vscode/mcp.json`:
```json
{ "servers": { "greenroom": { "type": "http", "url": "https://app.trygreenroom.dev/mcp" } } }
```
Windsurf, in `~/.codeium/windsurf/mcp_config.json`:
```json
{ "mcpServers": { "greenroom": { "serverUrl": "https://app.trygreenroom.dev/mcp" } } }
```
Cline, in `cline_mcp_settings.json`:
```json
{ "mcpServers": { "greenroom": { "type": "streamableHttp", "url": "https://app.trygreenroom.dev/mcp" } } }
```
OpenCode, in `opencode.json`:
```json
{ "mcp": { "greenroom": { "type": "remote", "url": "https://app.trygreenroom.dev/mcp", "enabled": true } } }
```
## Don't take your agent's word for it.
Hosted Greenroom checks web apps today, by invitation.
Join the waitlist: https://trygreenroom.dev/waitlist.
---
## How a harness gets made
This is the text version of https://trygreenroom.dev/harness, with the same content as the page.
A harness is one file in your repo, `.greenroom/harness.yaml`. It tells Greenroom how to start your app, so every run boots a fresh copy in a machine of its own.
.greenroom/harness.yaml (The least one needs):
```yaml
version: 1
start:
command: npm install && npm start
ready: http://localhost:3000/
```
Greenroom copies your code into the machine, runs the command and waits for the address to answer. That is enough for a first run.
### What the file turns into
One machine per run, each part made by one line of the file.
**One machine, one run**. Deleted when the run finishes
- **Your app's image** Built once, reused until the file changes. (`image.setup`)
- **Your code** Your working tree, uncommitted changes included. (`sync`)
- **Its own data** Seeded fresh for every run. (`data.seed`)
- **The app, running** Ready when its address answers. (`start`)
**A real browser, beside the machine**
Real clicks and keys. You can watch it live.
The verifier works here
**The edge** Every call that leaves the machine.
- **Allowed** Passes to the real host. (`edge.allow`)
- **Routed** Sent to a stand-in on a port in the machine. (`edge.routes`)
- **Everything else** Blocked, and listed in the report.
### The whole file
Every block, once. Only `version` and `start` are required.
.greenroom/harness.yaml (An example, every block):
```yaml
version: 1
image:
copy: [package.json, package-lock.json]
setup: |
npm ci
start:
command: npm start
ready: http://localhost:3000/health
timeoutSeconds: 120
data:
seed: node scripts/seed.js
sync:
exclude: [/dist, /coverage]
edge:
allow: [fonts.example.com]
routes:
api.payments.example: 4010
stress:
budgetSeconds: 300
skip: [offline]
security:
public: [/api/markets]
users:
- name: ben
headers:
Cookie: session=ben-demo-session
```
- `image`: `setup` runs once, when the image is built. `copy` lists the files it reads.
- `start`: `command` starts the app; `ready` is the address that means it is up. Waits 60 seconds, 600 at most.
- `data`: `seed` runs once per machine, before the app starts.
- `sync`: `exclude` names what is not copied in. `node_modules` and `.git` never are.
- `edge`: `allow` lets a host through; `routes` sends one to a stand-in in the machine. The rest is blocked.
- `stress`: After the verdict, a stress pass mashes, tabs, resizes and goes offline. 120 seconds, 600 at most.
- `security`: `users` gives a second person's headers, so a locked page can be asked for by someone who should not see it.
### How one gets made
Six steps, the same for every app. Each adds one block.
### Get it to boot
Write the file above and start a run. A wrong file or a failed start says why, in words.
What a failed boot says (In Greenroom's words):
```text
# the file is wrong
start.ready "localhost:3000" is not an http or https URL,
such as http://localhost:3000/
# the app is wrong
the start command "npm start" exited before
http://localhost:3000/ answered
```
### Move the installs into the image
Installs in `image.setup` run once, not on every boot.
.greenroom/harness.yaml:
```yaml
image:
copy: [package.json, package-lock.json]
setup: |
npm ci
start:
command: npm start
```
### Give each run its own data
A seed puts every run on the same starting data.
.greenroom/harness.yaml:
```yaml
data:
seed: node scripts/seed.js
```
### Decide every outside call
Boot once, read what the edge blocked, then allow each host or answer it from a stand-in.
.greenroom/harness.yaml:
```yaml
edge:
allow: [fonts.example.com]
routes:
api.payments.example: 4010
```
### Say who else can sign in
With a second person's headers, Greenroom checks that one person cannot read another's pages.
.greenroom/harness.yaml:
```yaml
security:
public: [/api/markets]
users:
- name: ben
headers:
Cookie: session=ben-demo-session
```
### Keep what worked
Greenroom keeps every version, and a project moves to a new one only after its app answered ready.
### Then Greenroom learns the app
Hosted Greenroom maps your app once per commit, so the verifier starts each run knowing its way around.
- **What it holds**: The pages, and what every control does when pressed.
- **How it is made**: By a crawler with no model, in a machine of its own, booted from the same harness.
- **Where it stays**: On Greenroom's side. Your report shows only what the verifier saw on your build.
### This site has one too
The file that boots this site for its own checks, as it is in the repo.
This site (wrangler dev, as production serves it):
```yaml
version: 1
# The site's own harness: Greenroom boots it in a web machine the way production serves it,
# `wrangler dev` on the real wrangler.jsonc with a local D1 (tests/support/serve.mjs), so the
# Worker's routes (the waitlist, the Markdown twins) answer as deployed.
image:
# The packages are installed once, into the image. A change to either file rebuilds it.
copy:
- package.json
- package-lock.json
setup: |
npm ci --no-audit --no-fund
start:
# The plain build: no PostHog key, so a run sends no analytics.
command: E2E_OUT=/tmp/greenroom-website node tests/support/build.mjs && E2E_OUT=/tmp/greenroom-website node tests/support/serve.mjs plain
ready: http://localhost:8791/
timeoutSeconds: 300
sync:
# The pictures a pull request shows are not part of the built site, nor is what a local test
# run leaves behind. The leading slash keeps each name to the repository's root.
exclude:
- /docs/screenshots
- /test-results
- /playwright-report
```
We test Greenroom the way it tests you: a change of ours merges only after a Greenroom run has tried it on the real app.
[Join the waitlist](https://trygreenroom.dev/waitlist)
We build Greenroom with Greenroom.
---
## Get early access to Greenroom
> Greenroom gives your coding agent a fresh machine with your app running in it. A second agent opens the app, clicks through it, and shows you what it saw before you merge.
This is the text version of https://trygreenroom.dev/waitlist.
Hosted Greenroom is open by invitation. Leave your email and we'll write to you when your spot opens. See one real run: https://trygreenroom.dev/ (in words: https://trygreenroom.dev/index.md).
### Joining
The form at https://trygreenroom.dev/waitlist asks for:
- **Email** (required)
- **Name** (optional)
- **Company** (optional)
- **What would you use it for?** (optional)
Joining gets you one thing: an email when your spot opens. We'll only email you about Greenroom. After you send the form the page says "You're on the list. We'll email you when your spot opens."
### For agents
If a person asks you to put them on the waitlist, send them to https://trygreenroom.dev/waitlist so they can enter their own email. Please don't post the form for them.
The form posts to `POST /api/waitlist` with a JSON body `{"email": "...", "name": "...", "company": "...", "use_case": "..."}` (only `email` is required; name, company and use case at most 200 characters each). The endpoint only accepts requests from the site's own pages (it checks the origin), so a request from anywhere else is refused with 403. It answers the same way whether the email is new or already on the list, and it allows 5 requests an hour from one address.
### The rest of the site
The home page plays one real Greenroom run in five acts: the claim, the boot, the check, the fix and the report. In words: https://trygreenroom.dev/index.md. How a harness gets made: https://trygreenroom.dev/harness.md