Wait Timer

Wait Timer

199-mcp

Adds a wait/sleep tool to workflows, letting you pause execution for a specified number of seconds. Useful when you need to wait for web pages to load, background processes to finish, or files to propagate before continuing.

Introduces deliberate pauses into workflows, ensuring time-dependent operations like web page rendering, background processes, or API calls have sufficient time to complete before proceeding to subsequent steps.

1334 views7Local (stdio)

What it does

  • Pause execution for specified duration in seconds
  • Wait for web pages to fully render after navigation
  • Allow time for background processes to complete
  • Ensure file operations finish before next steps

Best for

Web automation and scraping workflowsCommand line operations with background tasksAPI workflows needing processing delaysFile system operations requiring propagation time
Single simple toolNo setup required

About Wait Timer

Wait Timer is a community-built MCP server published by 199-mcp that provides AI assistants with tools and capabilities via the Model Context Protocol. Use Wait Timer to add intentional pauses in workflows, ensuring web pages, API calls, and other processes complete prope It is categorized under developer tools. This server exposes 1 tool that AI clients can invoke during conversations and coding sessions.

How to install

You can install Wait Timer in your AI client of choice. Use the install panel on this page to get one-click setup for Cursor, Claude Desktop, VS Code, and other MCP-compatible clients. This server runs locally on your machine via the stdio transport.

License

Wait Timer is released under the MIT license. This is a permissive open-source license, meaning you can freely use, modify, and distribute the software.

Tools (1)

wait

Waits for a specified duration in seconds.

MCP Wait Timer Server

An MCP (Model Context Protocol) server providing a simple wait tool.

Watch the demo video: https://www.youtube.com/watch?v=TaF_j9wrWVw

Overview

This server exposes a single tool, wait, designed to introduce deliberate pauses into workflows executed by MCP clients (e.g., Cline, Claude Desktop, Cursor).

Problem Solved

MCP clients and the AI models driving them often operate sequentially. After executing a command or action (like a web request, file operation, or API call), the model might proceed to the next step immediately. However, some actions require additional time to fully complete their effects (e.g., background processes finishing, web pages fully rendering after JavaScript execution, file system propagation).

Since the model cannot always reliably detect when these asynchronous effects are complete, it might proceed prematurely, leading to errors or incorrect assumptions in subsequent steps.

Solution: The wait Tool

This server provides a wait tool that allows the user or the AI prompt to explicitly instruct the client to pause for a specified duration before continuing. This ensures that time-dependent operations have sufficient time to complete.

Tool: wait

  • Description: Pauses execution for a specified number of seconds.
  • Input Parameter:
    • duration_seconds (number, required): The duration to wait, in seconds. Must be a positive number.

Use Cases

  • Web Automation: Ensure dynamic content loads or scripts finish executing after page navigation or element interaction.
    Example Prompt: "Navigate to example.com, fill the login form, click submit, then wait for 5 seconds and capture a screenshot."
    
  • Command Line Operations: Allow time for background tasks, file writes, or service startups initiated by a shell command.
    Example Prompt: "Run 'npm run build', wait for 15 seconds, then check if the 'dist/app.js' file exists."
    
  • API Interaction: Add delays between API calls to handle rate limiting or wait for asynchronous job completion.
  • Workflow Debugging: Insert pauses to observe the state of the system at specific points during a complex task.

Installation & Setup

This server requires Node.js (version 16 or higher).

Step 1: Configure Your MCP Client

Add the following JSON block within the "mcpServers": {} object in your client's configuration file. Choose the file corresponding to your client and operating system:

Configuration Block:

    "wait-timer": {
      "command": "npx",
      "args": ["mcp-wait-timer"],
      "env": {},
      "disabled": false,
      "autoApprove": []
    }

Client Configuration File Locations:

  • Claude Desktop:

    • macOS: ~/Library/Application Support/Claude/claude_desktop_config.json
    • Windows: %APPDATA%\Claude\claude_desktop_config.json
    • Linux: ~/.config/Claude/claude_desktop_config.json (Path may vary slightly)
  • VS Code Extension (Cline / "Claude Code"):

    • macOS: ~/Library/Application Support/Code/User/globalStorage/saoudrizwan.claude-dev/settings/cline_mcp_settings.json
    • Windows: %APPDATA%\Code\User\globalStorage\saoudrizwan.claude-dev\settings\cline_mcp_settings.json
    • Linux: ~/.config/Code/User/globalStorage/saoudrizwan.claude-dev/settings/cline_mcp_settings.json
  • Cursor:

    • Global: ~/.cursor/mcp.json
    • Project-Specific: Create a file at .cursor/mcp.json within your project folder.
  • Windsurf:

    • ~/.codeium/windsurf/mcp_config.json
  • Other Clients:

    • Consult the specific client's documentation for the location of its MCP configuration file. The JSON structure shown in the "Configuration Block" above should generally work.

Step 2: Restart Client

After adding the configuration block and saving the file, fully restart your MCP client application for the changes to take effect. The first time the client starts the server, npx will automatically download the mcp-wait-timer package if it's not already cached.

Usage Example

Once installed and enabled, you can instruct your MCP client:

"Please wait for 10 seconds before proceeding."

The client's AI model should recognize the intent and call the wait tool with duration_seconds: 10.

Developed By

This tool was developed as part of the initiatives at 199 Longevity, a group focused on extending the frontiers of human health and longevity.

Learn more about our work in biotechnology at 199.bio.

Project contributor: Boris Djordjevic

License

This project is licensed under the MIT License - see the LICENSE file for details.

Alternatives

Related Skills

Browse all skills
dotnet-backend

.NET/C# backend developer for ASP.NET Core APIs with Entity Framework Core. Builds REST APIs, minimal APIs, gRPC services, authentication with Identity/JWT, authorization, database operations, background services, SignalR real-time features. Activates for: .NET, C#, ASP.NET Core, Entity Framework Core, EF Core, .NET Core, minimal API, Web API, gRPC, authentication .NET, Identity, JWT .NET, authorization, LINQ, async/await C#, background service, IHostedService, SignalR, SQL Server, PostgreSQL .NET, dependency injection, middleware .NET.

64
ui-design-system

UI design system toolkit for Senior UI Designer including design token generation, component documentation, responsive design calculations, and developer handoff tools. Use for creating design systems, maintaining visual consistency, and facilitating design-dev collaboration.

6
cli-builder

Guide for building TypeScript CLIs with Bun. Use when creating command-line tools, adding subcommands to existing CLIs, or building developer tooling. Covers argument parsing, subcommand patterns, output formatting, and distribution.

2
swift-concurrency

Expert guidance on Swift Concurrency best practices, patterns, and implementation. Use when developers mention: (1) Swift Concurrency, async/await, actors, or tasks, (2) "use Swift Concurrency" or "modern concurrency patterns", (3) migrating to Swift 6, (4) data races or thread safety issues, (5) refactoring closures to async/await, (6) @MainActor, Sendable, or actor isolation, (7) concurrent code architecture or performance optimization, (8) concurrency-related linter warnings (SwiftLint or similar; e.g. async_without_await, Sendable/actor isolation/MainActor lint).

1
openai-knowledge

Use when working with the OpenAI API (Responses API) or OpenAI platform features (tools, streaming, Realtime API, auth, models, rate limits, MCP) and you need authoritative, up-to-date documentation (schemas, examples, limits, edge cases). Prefer the OpenAI Developer Documentation MCP server tools when available; otherwise guide the user to enable `openaiDeveloperDocs`.

0
api-documenter

Master API documentation with OpenAPI 3.1, AI-powered tools, and modern developer experience practices. Create interactive docs, generate SDKs, and build comprehensive developer portals. Use PROACTIVELY for API documentation or developer portal creation.

0