Bench

@Bench sleep for 2 seconds while I test this workflow's timing behavior

Slept for 2.0 seconds as requested. This pause can help you verify sequential task execution, simulate network latency in development environments, or introduce deliberate delays between API calls to avoid rate limits in other integrations.

This MCP provides a single utility: controlled sleep. It's useful for testing async workflows, pacing multi-step automations, or debugging race conditions in Spaces that chain multiple tool calls. No side effects beyond time delay.

@Bench pause execution for 5 seconds before the next step in this deployment checklist

Execution paused for 5.0 seconds. The sleep completed successfully. You can now proceed with the next item in your checklist. This delay is often used to allow external systems time to propagate changes before verification steps run.

Bench doesn't interact with external services—it only blocks the current execution thread. Useful when coordinating with other MCPs that need propagation time (DNS updates, cache invalidation, CI pipeline triggers). Maximum sleep duration depends on your Space's timeout settings.

@Bench wait 3 seconds between each batch of database migration queries to avoid overwhelming the connection pool

Slept for 3.0 seconds. This interval can be repeated in a loop to throttle operations. For database migrations or bulk API operations, inserting sleep calls between batches helps prevent connection exhaustion, timeout errors, or triggering vendor rate limits on downstream services.

Bench is a timing primitive, not a scheduler. It blocks synchronously—if you need parallel execution with staggered starts, you'll need to structure your Space's workflow accordingly. No authentication required; no external dependencies.

When you need controlled delays in integration tests

A 3-person backend team runs nightly integration tests against a staging API that processes webhooks asynchronously. They need to insert precise wait intervals between POST requests and GET assertions to let the queue drain. The Bench MCP's sleep tool gives them programmatic control over those delays without hardcoding timeouts in test scripts. This works when your test runner doesn't expose native sleep or when you're orchestrating tests across multiple agents in Switchy. The trade-off: if you're already using pytest or Jest with built-in wait utilities, adding an MCP for a single sleep function is overkill. Use Bench when you're coordinating timed pauses across agents that don't share a runtime.

Throttling API calls without custom retry logic

A 2-person data team pulls customer records from a third-party CRM that enforces a 10-requests-per-minute limit. They use Switchy agents to batch-fetch contact lists, and the Bench sleep tool lets them insert 6-second pauses between batches without writing custom throttle code. This is the right call when you're prototyping or when the rate limit is simple and static. If your API has dynamic backoff headers or you're hitting multiple endpoints with different limits, you'll outgrow a basic sleep tool fast and need a proper rate-limit library. Bench fits the narrow case where you just need a metronome between requests.

Slowing down agent actions for human comprehension

A solo founder runs live product demos where a Switchy agent automates a multi-step workflow—creating a project, assigning tasks, generating a report. Without pauses, the agent completes everything in under 2 seconds and the client misses the narrative. The Bench sleep tool inserts 3-second delays between steps so the demo feels like a guided tour instead of a blur. This is useful when you're presenting to non-technical stakeholders who need to see each action register. The boundary: if you're demoing to engineers or doing async screen recordings, you don't need real-time pacing and the sleep tool just wastes clock time. Use Bench when human attention is the bottleneck.