A simulated workplace for AI agents.

Gmail, Slack and Calendar in depth. Notion and Drive coming. 100+ more via Composio.

Let the agents you build for your employees act in Gmail, Slack and Calendar without touching the company's real systems. The tools behave like production and the data looks real. Every run comes back with a full trace and an evaluation that shows what to improve.

See an example run How it works

Works with any agent that calls tools over HTTP or MCP. Data stays in the EU.

Hover overTap a numbered agent to see what it is working on.

Bring your agent from

OpenAI Agents SDK
Claude Agent SDK
LangGraph
Vercel AI SDK
Mastra
CrewAI
or any agent that calls tools over HTTP

You cannot test an agent on the real thing.

An agent built for your employees does its work inside the company's live systems: inboxes, calendars, chat. Testing it there is slow, unsafe and impossible to repeat, so teams ship on a demo and a feeling.

Not repeatable

Live systems change under you. You cannot tell a regression from a different day.

Hard to evaluate

Did it finish the task, or just stop? With live systems you read logs and guess.

Risky

A test run that emails a customer or deletes a document is not a test.

Build, run, evaluate.

Three steps. Every run returns one object with the trace and the evaluation.

Step 1

Set up the office

Start from a template office: the tools, seeded with realistic data, saved once. Every run starts from the same state.

Step 2

Put the agent to work

Point your agent at the environment and give it a task. Every tool call is recorded with its arguments and result, in order.

Step 3

Review how it went

Evaluators compare the end state with the task, return a score, and say what fell short so you know what to fix.

A few lines to a first run.

Your agent runs where it already runs. Create a run on a template environment, point your agent at the run's tools address or its MCP address, and read the run back when it is done: the trace and the evaluation on one object.

HTTP API Python SDK · soon TypeScript SDK · soon

Docs and the API reference. The Python and TypeScript SDKs follow.

curl -X POST https://api.testworld.dev/v1/runs \
  -H "Authorization: Bearer $TESTWORLD_KEY" \
  -H "Content-Type: application/json" \
  -d '{"environment": "offsite-planning",
       "task": "Schedule the Q4 offsite"}'
# 201 {"id": "run_7f3a", "status": "created",
#      "tools_url": "https://api.testworld.dev/v1/runs/run_7f3a/tools",
#      "mcp_url": "https://api.testworld.dev/v1/runs/run_7f3a/tools/mcp",
#      "token": "tw_run_…", ...}

# Point your agent at tools_url (the real APIs' shape) or mcp_url (MCP), with token as its key.
# When it is done:
curl https://api.testworld.dev/v1/runs/run_7f3a \
  -H "Authorization: Bearer $TESTWORLD_KEY"
# 200 {"id": "run_7f3a", "status": "done", "calls": 5,
#      "trace": {"calls": [...]},
#      "evaluation": {"score": 1.0, "passed": true, ...}}

from testworld import Environment, run

env = Environment.from_template("offsite-planning")
result = run(env, agent=my_agent,
             task="Schedule the Q4 offsite")
print(result.score, len(result.trace))  # 1.0 5

import { Environment, run } from "testworld";

const env = await Environment.fromTemplate(
  "offsite-planning");
const result = await run(env, { agent: myAgent,
  task: "Schedule the Q4 offsite" });
console.log(result.score, result.trace.length); // 1.0 5

One run, end to end.

The agent gets a task, works through the office, and comes back with a trace and an evaluation.

run_7f3aSchedule the Q4 offsite Passed 1.05 steps · 11.1 s

#	Tool	Action	Result	Time
1	Gmail	Read thread “Q4 offsite”	3 messages, two dates proposed	1.8 s
2	Calendar	Check availability for 6 people, Nov 12–14	Nov 13 free for everyone	2.1 s
3	Slack	Post date poll in #leadership	6 of 6 reacted	3.4 s
4	Calendar	Create “Q4 offsite”, Nov 13, all day	Event created, 6 invites sent	1.2 s
5	Slack	Post the date and agenda in #general	Posted, 6 people notified	2.6 s
	Evaluation	Event exists#general toldNo email sent		1.0

The tools you can simulate.

Three tools are simulated in depth and checked against the real APIs. The rest of the catalog gives breadth. Every tool is seeded with realistic data and reset between runs. Missing one? Request a tool

GmailCore

Inbox, threads, labels, drafts and send

SlackCore

Channels, threads, DMs, reactions, search

CalendarCore

Events, invites, availability

NotionComing

Pages, databases, properties, comments

DriveComing

Files, folders, sharing, document text

100+ more via Composio

GitHub, Linear, Jira and the rest of the catalog. Breadth, not depth: less realistic than the core.

What you can use it for.

Start with one. All three run on the same seeded office.

Regression suites before release

Forty tasks, the same seeded office, run on every version. A score that drops tells you which change broke what.

Model and prompt comparisons

Same task, same data, different agent. Compare traces side by side instead of arguing from one demo.

Training data from real behaviour

Export traces with their evaluations. Failed runs become test cases, good runs become examples your agent learns from.

Questions

The short answers. The long ones ship with the docs.

Does the agent know it is simulated?

No. The core tools, Gmail, Slack and Calendar, expose the same APIs and data shapes as the real ones and are checked against them, so your agent calls them the way it would in production. The wider catalog is less exact.

Which agent frameworks work, and where does my agent run?

Your agent runs where it already runs, on your machine or your servers. testworld hosts the tools. You create a run over HTTP and point your agent at its tools address: the core tools answer on the real APIs' shape, so the agent only swaps its base URL and key. An MCP client connects to the run's MCP address instead. Either way every call is recorded. The Python and TypeScript SDKs follow the API.

Can I use my own data?

Templates come seeded and ready. Generating an office from a description of your business, and importing your own anonymised data, come after.

How is a run evaluated?

Checks on the end state: did the event get created, was #general told, was no email sent. Every template ships with its checks and you can add your own. Each check passes or fails with a one-line explanation, and the score is the share of checks that passed.

Can the agent learn from runs?

Yes. Traces and evaluations are exportable, so failed runs become regression cases and good runs become examples or training data.

Does anything reach real systems?

No. Each run gets its own isolated environment with seeded data and no real credentials. Nothing the agent does leaves it. Traces belong to your workspace and are stored in the EU.

What does it cost?

Early access is free while we onboard the first teams. After that the price is per call to the simulated tools, with monthly plans that include calls and a free plan.

Coming soon

Worlds for your kind of business. Same traces, same evaluations.

Industry packs: a simulated office with the systems a business actually uses, not only the generic office tools. Accounting first, with Tripletex, Fiken and PowerOffice.

Get early access

A simulated workplace for AI agents.

Get early access, free while the first teams onboard. Built for teams that build agents for their own employees.