Rooms compiles a faithful, stateful twin of your real systems from your own traffic, so you can test, certify and train AI agents before they touch the real thing.
Self-hosted by default · REST and MCP today · Exports to the OpenEnv standard
# 1. capture real traffic once (or import HAR / OpenAPI) $ rooms record --upstream https://api.hubspot.com --out traffic/ # 2. compile it into a room $ rooms compile traffic/ --out acme-hubspot.room # 3. run the room inside your environment $ rooms up acme-hubspot.room --port 8080 # 4. run scenarios against your agent, in CI $ rooms run scenarios/ --agent "python run_agent.py" \ --trials 3 --report out/ lead-import ✔ 3/3 no duplicates, opt-outs untouched rate-limited ✔ 3/3 backed off on 429s payroll-november ✘ 2/3 gross: want 15,495.88, got 14,500 report → out/report.html · out/junit.xml
Payroll, HR, banking back-office, insurance and government portals hold the work worth automating. They also have no sandbox, strict rules on personal data, and exactly one correct answer.
Legacy and regulated systems rarely offer a staging tenant. Teams test agents on real records, or on mocks that drift from reality within weeks.
The traffic that shows how a system really behaves is full of names, IDs and salaries. Shipping it to a third-party cloud is a non-starter.
A payslip is right or wrong to the shekel. You need to check the end state of the system, not the transcript, and you need it in CI on every change.
A room is a fake, stateful version of a system, served at a URL. Your agent calls it exactly as it would call the real thing.
Proxy real traffic, or import HAR files, OpenAPI specs and logs. PII is redacted at capture.
Traffic becomes a room spec: resources, state transitions, seed data and starting scenarios. You review it.
Start the room next to your agent. Each run gets its own session, so 50 parallel runs never share state.
Each scenario sets a starting state, a trigger and an expected end state. We diff the room's state and report pass/fail per assertion.
Capture ──────► Compiler ──────► Room runtime ◄────── your agent
(proxy, HAR, (traffic → spec, (stateful fake: REST / MCP / web) (unchanged, base URL swapped)
logs, PII seed data, control API: reset(seed) · state() · inject(fault)
redaction) scenarios) │
▼
Runner + Grader ──────► Report (HTML + JUnit for CI)
▲
User simulator (only for conversational inputs)
Webhooks fire only where the real system sends them: if a new ticket triggers your webhook in production, the room sends the same webhook during a test.
The compiler and rooms ship as a Docker container that runs in your VPC. Your traffic, and the personal data in it, never leaves your infrastructure.
Rooms keep state across calls, enforce the real system's constraints (duplicates, required fields, rate limits) and return its error shapes. The goal: a new system twinned in a day.
Rooms export in the OpenEnv standard, so the trainers and eval tools you already use can run inside them. No lock-in to our dashboard.
The room knows the true end state, so grading is a diff, not an opinion. Run k trials per scenario and get HTML reports plus JUnit XML for your pipeline.
A twin of a legacy payroll back-office (employees, payslips) and the inbox where change requests arrive. The agent reads the email, updates the employee, issues the payslip.
Point an access-review or connector agent at a twin of an app's identity API and compare what it reports with what's really there.
A HubSpot-style CRM with your properties, duplicate rules and opt-outs. Flip a tenant to test mode and run your flows against it.
A Zendesk-style ticket system plus a user simulator built from your historic tickets, so the agent faces realistic customers.
Replicas of government and insurance portals, served at a staging hostname your browser agents open. Inject UI changes to catch breakage before it ships.
We're onboarding a small group of design partners in Israel and the UK. These are starting points for a pilot conversation, not a rate card.
Flat fee. We build the twins of your systems with you.
Base fee including 3 rooms.
Licensed by room count, for teams that run everything in-house.
A fake, stateful version of one of your systems, served at a URL. It accepts the same calls as the real system, keeps state between them, enforces the same rules and returns the same errors. Your agent points at it by swapping a base URL; each run uses a session ID so parallel runs stay isolated. A control API lets your tests reset it to a seed, read its state and inject faults like latency, 500s and rate limits.
In your environment, as a Docker container. The compiler and the rooms run next to your agent, in your VPC or CI. A hosted option for synthetic-only data may come later.
Because everything runs inside your infrastructure, captured traffic never leaves it. Personal data is redacted at capture, and seed data in a room can be fully synthetic while keeping the shape and edge cases of the real records.
REST APIs and MCP servers today. Web portals for browser agents are next. Voice comes later, through a partner.
No. We don't do training, inference or GPUs, and we're not a generic eval dashboard. We build the rooms; your trainers and eval tools run inside them through the OpenEnv export.
Our target is a new system in a day, and that's the number design partners help us prove. During a pilot we build the twins with you and track the time each one takes.
Tell us which systems it touches and how you test it today. We'll come back with what a room for it would look like.