Closed beta · run Worlds on your machineBrowse worlds →
Docs menu · Dashboard

Dashboard

Use the dashboard to describe a test, review its starting situation and success rules, run your agent, and understand the outcome. Test files and run history stay in your project.

The integration candidate opens on Tests. Published beta.5 retains its released interface. The sidebar groups Tests and Runs under Testing, and Templates, Data and Worlds under Resources. Settings contains workspace and engineering configuration. The interface uses Sparta's light workspace palette with charcoal text and orange accents, with a collapsible sidebar and a keyboard-accessible menu on narrow screens. Earlier published packages retain their version’s navigation.

Start with the installation guide. For an existing installation, see launching and reopening the dashboard.

Check connector scope for available resources, imports and outcomes before building a test.

The private Gmail, Linear and Google Workspace feature candidate adds connector-specific manual/AI preparation, linked synthetic starting records, scoped identity controls and native state outcomes to this shared journey. Use its state-workflow guide for supported families, offline bindings and grading limits; check current delivery status before expecting these controls in a published package.

For a prepared walkthrough, open Tests → Explore the included example. The six-ticket demo guide covers a fresh package install, review, failed and corrected runs, recorded before/after evidence and repetition. Both scripted agents and all inputs ship with the runtime; no AI provider or additional setup is required.

Explore starter workflows

Templates opens Examples, with Starter workflows above the starting-data templates. Explore starter workflows on both the empty and returning Tests screens leads to the same section. Customer Desk, Team Inbox and Digital Shop show their public missions, supported scope and synthetic-data labels. Browsing creates no worlds.

Wherever you choose a system, a starting-data template or a test workflow, the dashboard shows four separate facts about it on this host: whether it is listed in the catalog, whether it is installed, whether tests can be authored here and whether tests can run here. A fact the host cannot establish reads as unknown; it is never shown as yes or no. "Cannot run tests here" gives a cause only when one is known (the system is not installed, or the connected runtime does not provide it), and a workflow's limitations are shown separately, labelled as limitations. The connector's own qualification text is shown as written. Being listed or installed is not a statement about provider verification. These facts come from the delivery inventory the host computes for the installation it is running in. Installed is checked on disk, including the starting data and task files a system's examples read, and a workflow whose system is not installed is refused before a run. Beside a provider's name the dashboard also shows its release scope as this installation reads it, naming the release record that states it; an installed package carries no release record, so its release scope reads as unknown.

Current source opens Open starter inside the dashboard. Choose a mission, inspect its records, use Run scripted example, introduce the supplied failure condition, then Grade result. Connect my agent exposes the existing connection and command handoff for your own agent. Reset world is explicit; stop an external agent before resetting. These experiences keep their existing state-based graders and their separate runtimes, so they remain usable when the main dashboard runtime is stopped. Published beta.5 retains its earlier separate-tab launch until a later release includes this change.

Temporary starter worlds last while the dashboard host runs. Create an editable project to keep its inputs, world state and attempts under starter-projects/ in the current workspace. Project inputs edits the existing starting-data, mission and checks documents with conflict detection. Saved starter projects on Tests reopens them; Starter attempt history on Runs leads to recorded results. Saved history shows captured checks, records, changes and requests with JSON/HTML downloads. Later edits or resets do not rewrite earlier attempts. The starter guide covers the underlying project and agent contracts. Your templates retains reusable saved starting setups and their existing URLs.

Create your first test

On Tests, choose New test and answer What should your agent do? You can start before your agent or drafting provider is connected. The brief saves privately on the host. Add an optional text policy or starting records, then choose Generate Use Cases when AI drafting is configured, or use Bring my own cases or data.

An engineer configures Settings → Agent connections and, optionally, Settings → AI drafting once for the workspace. Agent profiles retain the command, working directory, timeout and supported endpoint mappings. Drafting configuration retains an explicit provider, model, private environment-file path and credential variable name; secret values stay in that host file. Engineering links retain the handoff to the same saved draft. The dashboard pairs each browser tab with the local host: a reloaded or duplicated tab stays paired, while a tab opened by middle-click or by pasting the address may not inherit the pairing in some browsers and then asks you to pair again. The printed link works once and expires after five minutes; run the same worlds dashboard command again for a new one (deployment guide). Every request the dashboard makes, including reads and downloads, carries that pairing; the session cookie alone grants nothing.

In AI drafting, choose OpenAI or Anthropic and enter the host credential reference, then choose Load available models to retrieve the models visible to that key. Select a model from the list or enter its exact identifier manually, then save the drafting connection. Loading models does not save settings or start generation. Availability in a provider's catalog does not establish support for structured test generation; incompatible models produce a recoverable error, and the dashboard never substitutes another model. Changing the provider or credential reference clears the loaded catalog.

Before drafting, the dashboard explains that it may ask the selected model to correct an invalid submission once. This sends the same selected input, the generated submission and safe validation details to that provider. Both requests belong to the same attempt and share its deadline and cancellation. The latest-attempt receipt identifies the model actually used and whether a correction was requested.

Each model request of an attempt, including a correction request, also keeps its own receipt: the provider and model that were configured, the model the provider reported, and the token usage it reported. A value the provider did not return reads as not available; it is never copied from the configured model, estimated or shown as zero. While a draft is still running the list refreshes with the drafting status, and its in-flight statements say they are as of the last check. An attempt saved before these receipts existed says that no receipt was saved, so its model and usage are unknown.

AI drafting can propose synthetic starting records and test cases for the finite workflows listed in AI drafting. Describe the relevant people, records, relationships and business rules in the brief, then review the proposed data before accepting it. The accepted seed is reused for subsequent tests without another model call. Other connector profiles may support validated seeds without an AI drafting adapter; the drafting workflow and connector scope distinguishes those capabilities.

A rejected drafting request leaves its linked brief visible with a recovery message. Credential and model settings must be corrected before trying again. If submission status is uncertain, recover the saved attempt first; recovery does not issue another provider request. Cancelling keeps the last accepted data and cases. If completion already won the race, the saved completed result remains authoritative. Malformed saved attempt records are preserved for diagnosis instead of being silently replaced or dispatched again.

Review the test in three sections:

Section Review
Starting data People, records, relationships, starting time and imported or synthetic data.
Test cases Independent cases, or ordered steps that share one world.
Success rules Expected changes, shared credit allowance and records that must remain untouched.

In the case review, each starting record shows where it came from when a saved receipt proves it: imported, from an exported world, or synthetic. An edited record, a hand-written one, or one whose source no longer matches its recorded hash reads "Origin: unknown"; the dashboard does not guess. A list of more than 20 cases is shown 20 at a time with its totals, and the case you were working on is remembered when you leave and return. Shorter lists look and behave as before.

Edit the summaries in place. Answer missing account or outcome questions explicitly. Matching names and email addresses never establish a cross-system binding. Unsupported requirements remain visible; excluding one records that it is ungraded. Advanced source editing is available for rules that cannot be represented losslessly by the forms.

Each test uses one grading currency. A refund targeting a payment in another currency needs review and cannot be saved as that test's monetary rule. Use matching-currency starting records or a separate test; the editor preserves the original amounts without converting them.

Choose Save test, or Save and run when a reusable agent connection is selected. That action reviews the current revision and saves ordinary private seed/suite files without creating an exploratory world. New tests start with one repetition and normal conditions. Existing tests retain their other settings; a saved case subset requires an explicit scope choice when reopened here. Ordered steps run together: a partial selection of an ordered workflow is refused at review, at submission, in batches and on reruns, while an independent subset still runs. A saved selection can name version-1 tasks that have no explicit id, which are labelled by position. Such a selection is tied to the tasks file it was chosen against. If the file has changed, a run of the current configuration is refused until you choose the cases again. To do that, use Choose these cases again on the refusal in the run review. It first shows the subject each selected position names in the current file, and it is unavailable when a selected position no longer exists. If the file changes again before you confirm, nothing is chosen and the list is refreshed. You can also edit the selected task IDs under the suite's saved execution options, or run worlds test update <id> --input <file> with options.taskFilter. Each of these ties the selection to the file as it is now. A save that does not choose the cases keeps the earlier tie, so the refusal stays. Reruns of saved inputs are unaffected, and worlds test --case chooses cases for that one run.

Every run records one identity of the test that was accepted: its cases, starting data, selected scope, failure conditions and options, and any agent prompt, source or build files the agent profile declares. The run's inputs view shows whether that identity is recorded, absent (older runs) or does not belong to the run. If the test changes between your review and the submission, the run is refused and asks you to review it again.

Open Run settings in the review to change repetitions, failure conditions, detailed evidence capture or whether worlds remain available after grading. Presets are matched to the workflow's systems using their actual rules; descriptions and target labels explain their scope. Existing custom conditions remain intact with unverified compatibility labeled. Each rule lists the operation it matches, its target, how often it applies and its effect. A failure condition in which no rule can both reach a request of the test's own systems and have an effect is refused when you review, save, run or rerun, with the rule named, so a run cannot read as a failure test while using normal conditions; Use normal conditions removes it from that test and changes nothing else. Gmail tests are the exception: their failure recipe is checked against the test's declared recipe instead. Before a draft has starting data, the review says it cannot yet determine whether the rules apply. These choices save with the same review action and survive reloads. Selecting Normal conditions explicitly removes a saved failure preset. Open saved test files opens the complete task file when a test has already been saved.

If another editor changes a draft, Save edits as a copy preserves your reviewed content and effective run settings together. Recover saved copy resumes that same copy after an interrupted response or reload.

Earlier unfinished setups appear on Tests with a Resume action that returns to their saved progress. Existing files, worlds and earlier setup links remain valid.

Read results and try again

The result starts with its recorded overall outcome and affected cases. Select a finding to compare what should have happened with the observed change. Execution errors, incomplete runs and ungraded cases are distinct; finishing the process is not proof of a passing test. A world-level budget or protection can fail even when one case succeeded.

A run that ended without a result, because it failed to start, was cancelled, was interrupted, or its host stopped, shows a Saved run summary when you reopen it, including after a restart: what happened, the furthest stage any repetition reached, whether cancellation was requested, how many worlds were created and which kinds of evidence were saved. It never shows a grade, totals or a result that the run did not produce, and where the run's own record states an outcome it defers to that record. A cancellation you requested is recorded as a cancellation; a host stop or crash is not. A run that ended before these summaries existed says that no summary was saved. For an advisory review, only its final report counts as a result; retained samples are shown separately and are not counted in the summary.

Totals come only from the saved result, and the same calculation feeds the run page and the safe export, so they agree. Scope is stated only when it is established: a counted subset, the whole suite when the run recorded that with its list of cases, or not recorded.

Open saved rule and private records opens supporting local evidence that may contain sensitive text. The view places the saved rule beside the agent’s captured reply. Captured native support and combined workflows also show the bound account and relevant records in a Recorded before and after table, including refunds, credits, ticket state and subscription changes. Requested changes and protected subscriptions are labeled. Ordered workflows show the start and end of the whole workflow, not an inferred snapshot of each step; shared accounts are identified. The Whole-workflow allowance uses the complete run’s recorded aggregate, including when cases execute independently.

Supporting world changes opens the full recorded comparison, whose scope may include other cases in a shared workflow. Missing observations stay missing; captured excerpts are labeled. Older captures may lack unchanged starting records. A monetary value without a captured denomination stays in minor units rather than borrowing the expected rule’s currency. Identifiers, original findings and raw payloads remain available in details. Settings → AI drafting → Evidence for new tests controls reusable detailed capture, including private starting records. Existing tests keep their capture setting. These recorded comparisons remain unchanged when the retained world advances.

With detailed private evidence enabled, current source also retains bounded agent stdout/stderr and observed connector requests beside the selected case. Independent executions are associated with their case; ordered executions are labeled for the whole workflow. Output may be empty, truncated or unavailable, and older runs may have no trace. This is the agent program's emitted output, not hidden model reasoning. Request history does not establish which request caused each state change. The recorded state remains the grading authority.

The explicit case-and-trace download includes the selected case, recorded evidence, immutable input identities and the captured trace. Known credentials are redacted before trace storage, but customer text can remain sensitive; use the acknowledged private-evidence action to access or download it. Ordinary safe evidence exports omit traces. Run/world/task identities support local correlation without sending traces or enabling aggregate usage collection.

Explore future effects appears when the retained world supports clock controls. Choose the interval, then explicitly open the local records. Worlds creates the baseline and comparison automatically. This advances the retained world; it does not change the original grade.

Each exploration shows its recorded start and end, then refreshes the starting date for the next advance. If another tab changes the clock, the attempt asks you to review the current state instead of saving a misleading comparison. An older connected runtime may need updating before it supports this coordinated operation.

Inspect current world opens the retained world's live records beside the selected finding. Those records can contain sensitive data and later changes; the recorded grade and captured evidence remain separate. Evidence, exports and reproduction contains downloadable evidence, CLI reproduction and execution details.

The run page names the three ways to see a run again the same way wherever it offers them. Recorded playback reads what the run saved; no agent or model is called and nothing changes. Fresh rerun starts a new attempt as a separate run with its own result, linked back to this one. Live exploration opens a retained world's current state, which can differ from what was graded and never alters the recorded grade. None of these replays the agent's external actions deterministically.

Run again reuses frozen inputs in fresh worlds without reopening setup or generating another draft. Ordered workflows rerun together. Independent failure subsets remain available in developer reproduction controls. Compare with the previous run keeps the selected case and rule visible in both attempts.

Saved inputs do not freeze agent code or installed dependencies. A selected-case run does not establish that the whole test passes. Changed inputs remain visible in comparison. Reload never reruns or regenerates work; use a displayed recovery action after an uncertain response. Closing the browser leaves execution active while the host remains running.

Earlier world-first creation and reproduction tools

Open Worlds for world tools, Tests → Test files for the advanced suite editor, or the project name in the sidebar for the earlier overview. Existing saved worlds, configurations and deep links continue to work. The following instructions describe that retained workflow.

Create your first test

1. Create a world

On Overview, choose Create a world. Select the systems your agent uses, choose starting data, and give the world a recognizable name.

  • Templates provide ready-made starting data you can preview and customize.
  • Describe my workflow helps you prepare your own case.
  • Import my data starts from your cases or a supported export.

Review the included records, relationships and starting time, then choose Create and explore world. A world is an isolated working copy of that starting data. Creating one does not require an agent or a test suite.

To learn the workflow first, choose Try a guided sample on Overview. The billing, support and combined examples use scripted agents and need no provider key. Compare a failed run with its correction, then return to testing your agent.

2. Inspect the starting state

The world opens on State. Browse its records and relationships to check that your test has the information the agent needs.

Use Failure conditions to add a supported failure, such as a rate limit. Use Clock to advance logical time. Available controls depend on the connector.

Evidence lets you create a mark, a baseline for comparing later changes. A mark does not restore state. Manage → Reset world restores the world's starting state; creating another world leaves this one intact.

3. Connect your agent

Open Connect, then select an agent or choose Create an agent profile. Save its command, working directory and timeout. Follow the connector's instructions to point its SDK at the local world.

Profiles can reference a private environment file and map your agent's endpoint variables. Keep credentials out of version control. Source-account import credentials are separate from the local twin credentials.

Connection checks diagnose endpoint configuration. If your agent waits for a task, use a test to check its normal behavior. Copy developer setup instructions provides a handoff without credentials or answer keys.

4. Define the outcome

Choose Create test in the world. Select the original starting data and clock, or preview an export of its current state. Saving creates a suite: the tasks, starting data and expected outcomes that future runs will use.

In Test suites, edit each task's expected changes and protections. For example, a support task might require a particular status and assignee while protecting unrelated tickets. A billing task might require one specific refund and no changes to another customer.

Combined tests need explicit links between the relevant records. Matching names or email addresses do not establish those links. Written instructions alone are not grading rules; finish the structured expectations or supported YAML rules. Tasks without expectations remain labeled as ungraded.

5. Run fresh tests

Choose Run this suite, select the agent, and review the starting data, outcomes and run settings.

Mode When to use it
Independent tasks Test each task in its own fresh world.
Shared workflow Test an ordered set of tasks in the same fresh world.

Set Repetitions to run the test more than once. Save test keeps the configuration for later; Save and run fresh tests saves it and starts execution. You can save a test before an agent is connected.

Read results and try again

A completed process does not necessarily mean the test passed. Start with Outcome to see the evaluation, then open Evidence for task grades, recorded changes and available reports. A failed protection can fail the overall world even when an individual task was completed correctly.

A run page that names a provider shows that provider's qualification and release scope once, with the results. Reports, scoreboards, result files and the export carry the same lines.

The run page also says what is known about the agent's model. An agent started by a command has no way to state it, so it reads as unobservable. A browser agent may state its provider and model; that is shown as reported by the agent, not observed by Worlds. The bundled model reference shows the model id it read from the endpoint it called. The scripted control calls no model. A run saved before this was recorded reads as not recorded. None of this changes a result.

Open Reproduce to choose the next run:

Action What it uses
Rerun saved inputs The captured test data and execution settings.
Review current configuration Current project files and agent settings, reviewed before running.
Rerun selected failures from saved inputs Selected tasks with their saved inputs and protections.

Saved inputs do not freeze agent code or installed dependencies. A run of selected failures does not establish that the full suite passes. Compare runs identifies compatible tests; when inputs differ, inspect the evidence side by side.

If a submission loses its response, use the displayed recovery action before starting another. Reloading does not rerun work automatically. Keep the launcher terminal open while working; closing the browser leaves running work active.

Custom workflows from your own cases

For the retained import tools, open Worlds → Create a world, then choose Describe my workflow or Import my data. Name the preparation so you can resume it later.

  1. Add the request and starting situation. Choose an example, project dataset or supported source export for the records the task needs.
  2. For CSV, JSON or JSONL cases, review the field mapping and select the cases to include. Imported request text does not supply missing business records. A problem in a source names where it is (the data row, the line in the file and the mapped field, or the line and column of a JSON error) without repeating the content of the cell.
  3. Review each case's relevant objects, proposed outcomes and protections. Confirm relationships explicitly, especially across connectors.
  4. Choose Review prepared test files, inspect them, then Save prepared workflow. Continue to Create and explore world and the test flow above.

Preparation is private and resumable. Changed starting data requires reviewing affected outcomes and relationships again.

Account imports and support exports

A scoped Stripe import can collect selected customers, invoices, charges or subscriptions with their supported dependencies. Review the sanitized records, omissions and starting date. The saved data is frozen; reruns do not contact the account again.

Native Zendesk accepts supported offline snapshots. Its Full JSON export path uses extracted ticket envelopes, users and optional organizations. Review the conversation cutoff, starting status, assignment, groups and agent identity. For resolved cases, exclude later resolution messages from the starting context. Live Zendesk ingestion is not supported. See the native workflow reference.

Combined datasets must have compatible starting times and non-overlapping connector data. Imports copy the supported state; they do not reconstruct a complete account history.

Delivery and deposit (browser and Stripe)

Choose Delivery and deposit (browser and Stripe) under Systems involved. Each case binds one bundled storefront delivery task, one Stripe customer and that customer's deposit charge; choose all three explicitly. Use manual-clock Stripe starting data only, with no storefront records or other connectors. The expected refund is derived when you save: the deposit charge minus the delivery task's total, or no Stripe change when they are equal. A success rule you enter must agree. Saving writes contract.json beside the seed and tasks file.

Before saving, the review shows what the agent will be given for each case: the delivery task and the billing request, read only.

Saving also checks every case in two temporary worlds on the local runtime, removed afterwards. A fixed control recipe buys through the storefront's purchaser API (no browser, no agent), and the delivery grader grades the frozen purchase. The Stripe half applies the derived refund through the Stripe API and is graded against the billing key. The reference must pass both halves. Each incorrect action must be rejected by the half it breaks: doing nothing, buying without refunding, refunding without buying, a wrong amount, a wrong card, a wrong charge when another eligible charge exists, or any refund when none is due. A case that fails, or whose checks cannot run, saves nothing, and checks that have not finished within five minutes save nothing either. These checks are control recipes, not browser qualification.

Run a saved delivery and deposit test from your saved tests. Choose a browser profile whose agent also calls the Stripe API twin: its independent HTTP access is set to the API twin, which is a declaration and not a sandbox. Profiles that cannot run the test are listed with the reason; with no profile, or none that can run it, the page says which and links to Browser testing, opened with the scripted delivery and deposit control selected. The choice is saved with the test, so worlds test uses it, and says how to choose one when none is saved; a choice you have made but not yet run is kept if you leave the page and come back. If the runtime cannot be reached, the run is refused with a message that names the runtime, before anything is started. Each case runs once, in its own fresh storefront world and its own fresh Stripe world. The agent is given one input: its public task and the connection to that Stripe world. Before the agent starts, the run saves a proof that both worlds are the reviewed starting data; if the proof fails, the agent is never started.

A case passes only when both halves pass. It fails when either half is proven to have failed, and it is inconclusive when a half is missing and neither failed. Each half is graded from its own world's saved state. An agent that calls a Stripe route the twin does not implement makes the Stripe half inconclusive, as in any run.

A run says what ran it. When the profile's agent is the bundled scripted reference, the run page, the history, the overview and the export label it a scripted control: it shows that the workflow runs here and does not measure any agent.

To see a saved test run before you connect an agent of your own, create that control: in Settings → Delivery testing (the page titled Browser testing), choose Try a reference agent, then Scripted delivery and deposit control, and press Create delivery and deposit control. It uses no model. Nothing is created until you press the button. It adds the bundled script and its generated adapter to the project's worlds folder, a private setup receipt under worlds/private, and one profile to your browser profiles, which declares calls to the Stripe API twin. It is created once: if the project already has a profile with the control's id, or anything other than the same contents where the script or the adapter would be written, the request is refused with a message that says so and nothing is changed. If the project's worlds folder is a link to another folder, the request is refused and nothing is written through the link. A Browserbase credential entered for the current session only is refused too, because a test run cannot read it. When a profile with the control's id is already saved, the page says so and offers that profile in place of the button. A script, adapter or profile you already have is never replaced, including one that appears while the control is being created; if creating fails for another reason after it has started, the control's own script or adapter may be left in place, and creating again uses them. Then choose the control when you run the saved test. Its runs are labelled a scripted control wherever a run is shown, by a check of the script's exact contents. If you edit the script, runs with that profile are labelled as your own agent from then on, not as a scripted control. A run is still accepted, but until you review and save the profile again in Browser testing, each case ends as a setup failure before the agent starts, with the finding that the browser profile could not be prepared. The connection diagnostic on the Delivery testing page is for browser-only profiles and does not run this control; run it from a saved delivery and deposit test.

Such a test runs alone. A batch, repetitions above one, failure conditions, the ordered-workflow mode, the advisory judge and extra expectations are each refused with their own message, and the raw worlds passk --tasks command refuses the file rather than run only its Stripe half. Creating a single world for this workflow is unavailable: each run creates its two worlds itself. A frozen rerun reuses the saved starting data, tasks, contract and profile, and is refused if the bundled delivery task or the profile has changed since.

Cancelling waits for the browser attempt to confirm its own cleanup, for up to 165 seconds, and the run page says so. End now, or a second Ctrl-C in the terminal, stops waiting; the browser cleanup is then reported as unconfirmed and its browser slot stays held until the receipt's retry window ends. A run ended this way has no case results: its page shows that it was interrupted and why. A run that ends without its result has its Stripe world deleted by the host, unless you asked to keep worlds, in which case the run page says the world is still there and still accepts the key its agent was given. If the dashboard itself stops in the middle of a run, the next start marks that run interrupted, runs nothing again, and deletes its Stripe world in the same way.

A finished run's report has a Joined timeline: for each case, the job journal, the Stripe requests, the Stripe world's changes, the storefront world's records and the browser attempt side by side. Rows are joined only where the same identifier was saved in both records. A storefront checkout that was accepted and the payment it committed are two rows joined by their operation. A Stripe request and the refund it created are never joined, because the request log saves no identifier for either; that link, the order of rows across lanes, and everything in the list under Not observed are stated as unknown. The view shows no identifiers, and the safe export carries only counts. The reviewed bindings of a case are in its private records instead: Open saved rule and private records shows, under Reviewed bindings, the delivery task, the account customer and the deposit charge the case was reviewed with, and the contract version and hash they were frozen under. They are read from the run's own saved contract; if that file is missing, unreadable, written by a newer Worlds, or not the one the run's accepted test sealed, the section says which and shows no identifiers. When only some cases were selected, the timeline says how many of the suite ran and names the rest by their position in the suite, and says that it does not establish that the whole suite passes.

When an agent reports that it was blocked, the report says what supports the cause. It is observed when the run's own storefront gateway captured the refusal, or the storefront page showed its notice at one of the agent's actions. It is recorded when the saved world state shows the run's own attempt. Otherwise it is unknown. The report names each channel as captured, cut at a bound, or not captured, and the timeline lists the captured refusals and page notices as their own rows, by code and without identifiers or amounts. This support never changes a result.

The one limit on recognition: a tasks.yaml copied elsewhere without its contract.json is an ordinary billing suite, and runs and is identified as a billing-only test. If contract.json is deleted, accept the reviewed preparation again to restore it.

With a model connected, you can describe the scenario and have it drafted, as for a billing test. The model proposes the Stripe starting data, each case's request and policy, one of the six bundled delivery tasks and the deposit charge. It is shown only what an agent would be given for each task, and record ids in anything it is sent are replaced by placeholder names; names, emails and amounts go as written, and the preview shows the exact payload before you send it. It never supplies the refund: a draft that states an outcome is refused, and the refund is derived when you save. Every drafted case and binding is marked for your review. A refused draft names the rule that refused it. The two-world checks run when you save, not while drafting.

Optional model drafting and private data

You can prepare tests manually without a model. Optional OpenAI or Anthropic drafting sends the content you select to the chosen provider. As disclosed before generation, an invalid submission may be returned to that same model once with the selected content and safe validation details for correction. The exact-content preview refreshes when the selection changes; unselected files and credentials remain excluded. Supply a private environment-file reference or a session-only key. Review the proposed revision, its assumptions and its outcomes before accepting it.

Accepted private test files live under worlds/private/. Keep environment files, identity maps and source-account credentials out of version control. Default evidence and CI exports exclude private text-bearing inputs; review download previews and prepare de-identified inputs before making a portable CI configuration.

Private reports may omit text or process output. Missing evidence is shown as missing, rather than inferred. Optional advisory analysis remains separate from the test's authoritative verdict.

Return to saved work

Tests shows unfinished drafts and saved tests. Open a draft to continue review, or use Run test to reuse saved inputs and the configured agent. Runs holds previous attempts and comparisons. The project name in the sidebar opens the earlier overview.

Saved work written by a newer Worlds is refused with a message that says so, and is left unchanged; update Worlds to read it. When a later version changes how a record is saved, the older file is never rewritten: Worlds writes a copy in the new form beside it, with a receipt naming both files, and reads the copy from then on. If an older Worlds keeps writing the original after that, the newer one refuses the record as changed after it was copied forward, with both files preserved; it does not choose between them for you.

In Templates → Your templates, reuse named starting data to create another world. Save as starting setup on a live world previews a reusable export of its current state; this does not preserve its full history or alter the live world.

Runs → Run tools → Saved tests and batches runs several saved configurations in order with one agent profile. Each result remains inspectable, and a failed test does not automatically cancel later tests. Preview the CI export to run reviewed configurations outside the dashboard.

Destination Use it for
Tests Describe, review, save and rerun tests; resume unfinished drafts. Test files opens complete task and policy files.
Runs Recorded outcomes, failure investigation, reruns, comparisons, local batches and explicitly imported evidence.
Templates Examples opens starter workflows and starting-data templates; Your templates holds reusable starting setups with optional failure conditions. Success rules belong to tests or the starter's missions.
Data Validated project/library starting records and supported imports. Use records to begin a template draft; no world is created. Private test attachments stay with their drafts.
Worlds Live and retained world instances, records, requests, failure conditions, clock, evidence, connections and lifecycle controls.
Settings → Workspace Local project/runtime tools, supported data sources, delivery testing and CI workflow export. No personal account is required.
Settings → Agent connections Reusable local agent commands, endpoint mappings and private environment-file references.
Settings → AI drafting Provider/model configuration, private credential references and evidence defaults. Secret values stay on the host; runtime and per-world credentials retain their existing controls.

CI workflow export prepares GitHub Actions files; PR status and history remain in GitHub. Delivery testing exposes the existing scoped browser adapters, including its registered MCP host option. If a project's browser attempt history was written by a newer Worlds version, the dashboard leaves it unchanged and asks you to update Worlds; it does not offer a retry. These tools live within their supported workflows, not separate integration, PR-history or general MCP products. Templates uses existing starting setups; failure-injection rules remain contextual controls. Earlier section URLs remain supported, including the superseded preview labels. Selecting a destination never generates a test, starts a run or provisions a world.