Deterministic Cron Engine MCP for AI. Get precise job timings, guaranteed.

Q: What is the difference between crontotext and texttocron?

They are opposites. crontotext takes code to plain words, while texttocron takes plain words and generates the correct code.

Claude

ChatGPT

Cursor

Gemini

Windsurf

VS Code

JetBrains

Vercel

See Vinkius in Action

Works with every AI agent you already use

…and any MCP-compatible client

Connect to your AI in seconds.

Deterministic Cron Schedule Engine gives your AI client precise scheduling math. It translates complex cron strings into plain English and back.

You can also calculate the exact future date when any schedule will run next. Stop relying on general LLM logic for time; use this MCP to handle all job timing calculations deterministically.

What your AI can do

Cron to text

Converts cryptic scheduling code into clear, readable natural language text.

Calculate next execution

Determines the exact future date and time when a given cron schedule will run next.

Text to cron

Translates plain English descriptions of schedules into mathematically valid cron syntax.

Calculate Next Run Time

You ask it for a specific cron schedule and get the precise date and time of its next execution.

Cron to English Text

It takes cryptic scheduling code and translates it into clear, everyday language.

English Text to Cron

You describe the schedule in plain words (e.g., 'Every weekday at 5am'), and it returns valid cron syntax.

Ask an AI about this

Included with Plan

Waiting for input…

AI Agent

Deterministic Cron Schedule Engine: 3 Tools

These three tools let you convert scheduling descriptions into code, generate readable text from raw schedules, and calculate precise future run times.

Make your AI actually useful.

Add this MCP to Claude, Cursor, or Windsurf and your AI stops guessing. It gets real tools to look things up, take action, and handle the stuff you keep doing by hand.

Start using Deterministic Cron Schedule Engine on Vinkius

Cron To Text

Converts cryptic scheduling code into clear, readable natural language text.

Calculate Next Execution

Determines the exact future date and time when a given cron schedule will run next.

Text To Cron

Translates plain English descriptions of schedules into mathematically valid cron...

Security and governance baked right in.

Pick your AI client below to get set up. Just create a Vinkius account, subscribe, and you're instantly up and running. We handle the entire backend infrastructure, delivering out-of-the-box support for HTTPS Streamable, SSE, and OAuth2—zero messy routing required.

Claude AI

Open Claude Settings

Go to claude.ai, click your profile icon, then navigate to Customize → Connectors.

Add Custom Connector

Click the "+" button and select Add custom connector. Paste your Vinkius endpoint URL:

https://edge.vinkius.com/[YOUR_TOKEN_HERE]/mcp

Replace [YOUR_TOKEN_HERE] with your token from cloud.vinkius.com. For OAuth-protected servers, expand Advanced settings to add credentials.

Start a conversation

Open a new chat. The Deterministic Cron Engine integration is available immediately — no restart needed.

Antigravity

Configure Agent Environment

Open your Antigravity agent's workspace configuration or mcp-servers.json file.

Bind the Endpoint

Add the Vinkius endpoint URL to your agent's MCP connections list:

"mcp_servers": {
  "deterministic-cron-schedule-engine": {
    "serverUrl": "https://edge.vinkius.com/[YOUR_TOKEN_HERE]/mcp"
  }
}

Provide your secure token in place of [YOUR_TOKEN_HERE] to ensure your agent requests are authenticated.

Execute

Start your Antigravity session. The agent will autonomously discover and utilize the Deterministic Cron Engine tools with full Vinkius guardrails applied.

VS Code Copilot

⚡

One-Click Install (Recommended)

In your Vinkius Dashboard, simply click the Add to VS Code button for this server. We'll automatically configure your local workspace.

Or configure manually

Open MCP Settings

Open VS Code, press Ctrl/Cmd + Shift + P, and search for GitHub Copilot: MCP Servers.

Add Server Config

Add the Vinkius endpoint configuration to your mcp-servers.json file:

"deterministic-cron-schedule-engine": {
  "url": "https://edge.vinkius.com/[YOUR_TOKEN_HERE]/mcp"
}

Ensure you replace [YOUR_TOKEN_HERE] with your token from cloud.vinkius.com.

LangChain

Install Dependencies

Install the LangChain MCP adapters for your environment:

pip install langchain-mcp-adapters

Connect the Server

Use the SSEClient in LangChain to connect to the Vinkius managed endpoint:

from langchain_mcp_adapters.client import SSEClient

# Connect to Vinkius
client = SSEClient(url="https://edge.vinkius.com/[YOUR_TOKEN_HERE]/mcp")
tools = client.get_tools()

CrewAI

Define the Tool

Load the Vinkius MCP tools into your CrewAI agents:

from crewai import Agent
from mcp_crewai import MCPTool

# Connect securely to Vinkius
vinkius_tools = MCPTool(url="https://edge.vinkius.com/[YOUR_TOKEN_HERE]/mcp")

# Assign to Agent
researcher = Agent(
    role='Data Researcher',
    tools=vinkius_tools.get_all()
)

Execute Task

Run your CrewAI process. The agent will autonomously route tasks to the Vinkius managed server.

Choose How to Get Started

Build a custom MCP for your own tools, or connect a ready-made integration from our catalog.

Build Your Own

Turn any API into an MCP. Import a spec, define Agent Skills, or deploy with MCPFusion.

Import from OpenAPI, Swagger, or YAML specs
Create Agent Skills with progressive disclosure
Deploy to edge with MCPFusion framework
Built in DLP, auth, and compliance on every call
Real time usage dashboard and cost metering
Publish to catalog or keep private

Start building

Make Your AI Do More

Start with Deterministic Cron Schedule Engine, then connect any of our 5,100+ other servers whenever your AI needs more. One click, no limits.

Use this MCP plus 5,100+ others, all in one place
Add new capabilities to your AI anytime you want
Every connection is secured and compliant automatically
Track usage and costs across all your servers
Works with Claude, ChatGPT, Cursor, and more
New servers added to the catalog every week

Deterministic Cron Engine MCP server cover

Independent Platform Disclaimer: Vinkius is an independent platform and is not affiliated with, endorsed by, sponsored by, verified by, or otherwise authorized by cron-parser. All third-party trademarks, logos, and brand names are the property of their respective owners. Their use on this website is strictly for informational purposes to identify service compatibility and interoperability.

VINKIUS INFRASTRUCTURE

Cloud Hosted

Managed infra

V8 Isolated

Sandboxed per request

Zero-Trust Proxy

No stored credentials

DLP Enforced

Policy on every call

GDPR Compliant

EU data residency

Token Compression

~60% cost reduction

Your data is protected. See how we built it.

Works with Claude, ChatGPT, Cursor, and more

The Model Context Protocol standardizes how applications expose capabilities to LLMs. Instead of operating in isolation, your AI gains direct access to external platforms, live data, and real-world actions through secure, standardized connections.

This connection provides 3 powerful capabilities that interface natively with Claude, ChatGPT, Cursor, and other compatible AI platforms. No middleware. No custom integration required.

Dealing with Scheduling Code Is a Nightmare

Today, when you build out job orchestration, the most tedious part is handling the time syntax. You have to translate human concepts—like 'the third Tuesday' or 'monthly on the first day'—into rigid cron strings (`0 0 */3 *`). Then, if a user asks for clarification, you copy-paste that cryptic code and hope your dashboard can render it into something readable.

With this MCP, you offload all of that complexity. You give your agent the plain language description, and it uses `text_to_cron` to build the perfect, valid schedule string instantly. Your application handles clean data, not confusing syntax.

Getting Precise Dates with calculate_next_execution

Before this MCP, figuring out when a job would run next required complex date libraries and custom math within your application code. You had to write logic that accounted for month lengths, leap years, and day offsets, all while hoping the language model didn't hallucinate the final timestamp.

Now, you just call `calculate_next_execution`. The tool handles the entire mathematical process deterministically. It gives a guaranteed next run time, saving you from building complex temporal loops yourself.

Support 24/7 support@vinkius.com ↗

Security Vinkius Trust Center ↗

SLA Service Level Agreement ↗

Report Listing Send Report ↗

What your AI can actually do with this

Scheduling tasks requires dealing with messy syntax, like 0 15 10 * *. Writing out exactly when a system needs to run is hard enough without needing an AI to calculate the next tick. This connector solves that math problem. It handles translating standard cron strings into human-readable sentences—and vice versa.

If you need to ask your agent, 'When exactly will this job fire again?' and get a precise date back, not a guess, this is what you use. You can offload the difficult scheduling logic entirely. By connecting it via Vinkius, your AI client gets reliable access to a dedicated algorithm built purely for time math.

Built · Hosted · Managed by Vinkius Cron Schedule Engine - Calculate Job Dates and Schedules

Server ID 019e3880-ab41-7271-9b59-eedb36801e22

Vinkius Inspector

Compliance Grade D

Score 61.25/100

Report View Report ↗

What Changes When You Connect

Stop guessing on dates. Use calculate_next_execution to get the exact next run time for any cron schedule, eliminating scheduling risk.

Simplify communication. Send a raw cron string to cron_to_text and instantly generate clear language for user dashboards.

Build better forms. Instead of asking users for code, use text_to_cron so they can just write 'every Monday at 9am' and get the correct syntax back.

Save compute cycles. The engine uses pure JavaScript loops to handle time math, keeping the process fast and dependency-free.

Improve reliability. You aren't trusting an LLM's internal calendar logic; you're calling a dedicated algorithm for absolute accuracy.

See it in action

01 01

Debugging Misaligned Schedules

A developer is debugging why a nightly report didn't run on time. They feed the cron string into calculate_next_execution, which immediately tells them the schedule was set incorrectly, pointing to a missed date.

02 02

Building User-Friendly Forms

A product manager needs users to input recurrence rules. Instead of writing complex instructions, they use text_to_cron to take 'Every two weeks on the 1st' and generate valid cron syntax for the backend.

03 03

Documentation Generation

A technical writer needs to document a system job. They pass the raw schedule code through cron_to_text and get 'Every third Sunday of the month,' which they can copy directly into release notes.

04 04

Validating Business Logic

A data scientist needs to confirm if a complex, multi-stage workflow will hit its next checkpoint on time. They use calculate_next_execution against the system's job schedule to get a guaranteed future timestamp.

The honest tradeoffs

Asking LLMs for Math

Anti-pattern

A user prompts: 'What is the next time 0 * * * * runs?' The AI might hallucinate or provide a date based on its training cutoff, which is useless.

The Fix

Don't rely on general chat ability. Use calculate_next_execution to force the math calculation through a specialized engine and get the guaranteed next run time.

Guessing Syntax

Anti-pattern

A user writes 'monthly on first day' and tries to manually convert it into cron syntax, resulting in an invalid or incorrect string.

The Fix

Use text_to_cron. This tool guarantees the output is mathematically valid cron syntax from your natural language description.

Translating Backwards

Anti-pattern

A user gets a plain English schedule ('Every Friday at midnight') and tries to remember the corresponding complex code.

The Fix

Use text_to_cron in reverse. It takes 'Every Friday at midnight' and outputs the precise cron expression you need.

When It Fits, When It Doesn't

Use this MCP if your job requires translating between natural language descriptions of time and structured, deterministic code (the cron format). Specifically, use text_to_cron when accepting user input for scheduling. Use cron_to_text when displaying a raw schedule to an end-user. Crucially, always call calculate_next_execution if you need to know the next run date; it is not optional for accurate time math. Don't use this MCP if your problem is merely generating example cron strings or listing general scheduling concepts. For that, basic LLM prompting might suffice, but never rely on it for actual deployment logic.

Questions you might have

How does calculate_next_execution work? +

It takes any valid cron schedule and returns the exact date and time of its next scheduled tick. It uses a dedicated algorithm to ensure the calculation is mathematically perfect, period.

Can I use text_to_cron for custom schedules? +

Yes. You can describe nearly any recurring schedule in natural language (e.g., 'every other day starting today'), and text_to_cron will convert it into valid cron syntax.

What is the difference between cron_to_text and text_to_cron? +

They are opposites. cron_to_text takes code to plain words, while text_to_cron takes plain words and generates the correct code.

Does this MCP handle time zones? +

The engine provides precise temporal calculations necessary for scheduling. Always confirm your expected timezone offset when calling any of the three tools to ensure accuracy across environments.

If I use text_to_cron with ambiguous natural language, how does it handle errors? +

It validates inputs mathematically before running. If your description is unclear or doesn't map to a valid cron structure, the MCP returns an explicit error detailing which part of the phrasing caused the failure.

Can calculate_next_execution process non-standard or proprietary scheduling syntax? +

No. This MCP requires standard, established cron expressions to work correctly. It relies on a robust V8 JavaScript algorithm designed specifically for traditional 5-field cron notation.

Does cron_to_text have any performance overhead or external dependencies? +

Absolutely not. The engine is built purely using native JavaScript temporal loops and has zero external dependencies, ensuring fast, reliable conversion without slowdowns.

When I run cron_to_text, what specific details does the natural language output include? +

The resulting text provides a clear, readable sentence that translates the technical frequency and time. It converts numerical fields into plain English, avoiding jargon like 'day of week' or 'minute marker'.

Why use an MCP for cron translation? +

Because AI models predict text probabilistically. They often invent invalid cron configurations or fail to understand exactly when a specific combination (like * * 1 * *) will trigger next. An algorithmic check provides certainty.

Does it support the standard 5-part cron format? +

Yes. It perfectly parses the standard 5-part expression (Minute, Hour, Day of Month, Month, Day of Week) heavily used in Unix/Linux and SaaS orchestrators.

Connect to your AI in seconds.

Cron to text

Calculate next execution

Text to cron

Deterministic Cron Schedule Engine: 3 Tools

Make your AI actually useful.

Cron To Text

Calculate Next Execution

Text To Cron

Security and governance baked right in.

Claude AI

Open Claude Settings

Add Custom Connector

Start a conversation

Claude Code

Open your terminal

Add the MCP Server

Start coding

Cursor

One-Click Install (Recommended)

Open Cursor Settings

Add New Server

Use in Composer

Antigravity

Configure Agent Environment

Bind the Endpoint

Execute

VS Code Copilot

One-Click Install (Recommended)

Open MCP Settings

Add Server Config

Windsurf

One-Click Install (Recommended)

Open Windsurf Settings

Add Server Endpoint

LangChain

Install Dependencies

Connect the Server

CrewAI

Define the Tool

Execute Task

Choose How to Get Started

Build Your Own

Make Your AI Do More

Works with Claude, ChatGPT, Cursor, and more

Dealing with Scheduling Code Is a Nightmare

Getting Precise Dates with calculate_next_execution

What your AI can actually do with this

Here's how it actually works

Who is this actually for?

What Changes When You Connect

See it in action

Debugging Misaligned Schedules

Building User-Friendly Forms

Documentation Generation

Validating Business Logic

The honest tradeoffs

Asking LLMs for Math

Guessing Syntax

Translating Backwards

When It Fits, When It Doesn't

Questions you might have