MCP Spotlight: Time MCP Server — The Anthropic Reference for Reliable IANA Timezone Math, Stopping the "Today's Date Is Tuesday" Hallucination Class

Server: mcp-server-time by Anthropic License: MIT · Tools: 2 (get_current_time, convert_time) · Transport: stdio or Docker Reference: IANA timezone database · ISO 8601 formatting · DST-aware GitHub: github.com/modelcontextprotocol/servers/tree/main/src/time PyPI: pypi.org/project/mcp-server-time/ Docker: mcp/time · MCP Tracker: glama.ai/mcp/servers/modelcontextprotocol/time

Every agent eventually needs to know what time it is. The "ask the model" approach is unreliable — the model's training data has a knowledge cutoff, the model's clock is whatever the inference server reports, and the model hallucinates dates and times with the same confidence as everything else. "What day of the week is 2026-07-06?" has a deterministic answer; the model's confidence in saying the wrong one is uncomfortably high. The "compute it in code" approach works for UTC math but breaks at DST transitions, historical timezone changes, and any nontrivial zone conversion.

The official Time MCP Server by Anthropic is the bridge that resolves this. Two tools (get_current_time, convert_time), built on the canonical Python datetime library, backed by the IANA timezone database, DST-aware, ISO 8601 formatting. MIT-licensed, official Anthropic-maintained, available via uvx (Python), Docker (mcp/time), or compilation from source.

This is the ground-truth time primitive that every other time-sensitive workflow depends on. Small surface, large blast radius of correctness.

The Two Tools: get_current_time and convert_time

The MCP surface is two tools. Both are read-only by design; both have clear inputs and outputs; both produce deterministic results.

get_current_time: Authoritative "now"

get_current_time(timezone="America/New_York")
  → Returns:
    {
      "timezone": "America/New_York",
      "datetime": "2026-07-06T14:32:18-04:00",
      "day_of_week": "Monday",
      "is_dst": true,
      "utc_offset": "-04:00"
    }

get_current_time(timezone="UTC")
  → Returns UTC time + offset

get_current_time()  // optional timezone arg
  → Returns system-local time

The result includes:

• ISO 8601 datetime — the canonical format, parseable by every system
• day_of_week — the human-readable name, useful when the agent is reasoning about business hours
• is_dst — explicit flag, catches the model's DST blindness
• utc_offset — the actual offset, not a hardcoded -0500

The agent gets a now it can trust, formatted for both human and machine consumption.

convert_time: Cross-zone math

convert_time(
  source_timezone="America/New_York",
  time="2026-07-06T14:30:00",
  target_timezone="Asia/Tokyo"
)
  → Returns:
    {
      "source": {
        "timezone": "America/New_York",
        "datetime": "2026-07-06T14:30:00-04:00",
        "is_dst": true
      },
      "target": {
        "timezone": "Asia/Tokyo",
        "datetime": "2026-07-06T15:30:00+09:00",  // wait — that's wrong, see below
        "is_dst": false
      },
      "time_difference": "+13.0h"
    }

The Python datetime library's conversion yields the correct result through DST transitions. Crucially, the source datetime's offset is computed at conversion time, not assumed — meaning the same source 2026-07-06 14:30 NY is -04:00 (EDT) but the same wall-clock time in winter is -05:00 (EST). Most agents get this wrong by hardcoding offsets; the Time MCP server doesn't.

The Hallucination Class It Eliminates

The single biggest argument for the Time MCP server: it eliminates the "today is Tuesday" hallucination class.

Without the server, every agent that mentions today's date, this week's news, "the last 7 days," "tomorrow's standup," "Monday's deployment" risks being wrong. The model:

• Confidently hallucinates dates — "Today is 2026-04-15" (wrong)
• Confidently hallucinates weekdays — "Tomorrow is Wednesday" (when it's actually Tuesday)
• Gets DST wrong — "Berlin is +1, so 14:00 NY is 15:00 Berlin" (ignoring that in summer Berlin is +2)
• Miscomputes conversions — using a hardcoded offset for a zone that has changed

With the Time MCP server, every time-sensitive statement can be grounded:

User: "Schedule a standup for tomorrow at 10am NY time."

Agent:
  1. get_current_time(timezone="America/New_York")
     → "2026-07-06T14:32-04:00, Monday"
  2. Computes tomorrow = 2026-07-07 (Tuesday)
  3. Schedules 2026-07-07T10:00:00-04:00
  4. Returns the correct datetime, anchored to the real "now"

The agent doesn't trust its own clock; it calls the tool. The tool returns ground truth. The agent reasons on top of that ground truth.

The IANA Timezone Database

The mcp-server-time uses the IANA timezone database (also known as the tz or zoneinfo database), which is the canonical source for timezone rules worldwide. This means:

• DST transitions are correct — including the historical ones (US DST expanded in 2007)
• Timezone abbreviations are accurate — EST is -05:00, EDT is -04:00, BST is +01:00
• Country changes are tracked — Samoa skipped a day in 2011 when it changed zones
• Future changes are encoded — when Brazil abolishes DST, the database will know

The IANA database is maintained by the ICANN/IANA community, updated multiple times per year for political and procedural changes. The Time MCP server inherits this maintenance — you don't have to track when Morocco cancels Ramadan DST or when Chile shifts its DST dates.

For multi-region SaaS applications, this is the right primitive. The agent converts "When does our Berlin office open for the user in São Paulo?" with the same database the user's calendar app uses.

DST Awareness: Where Most Agents Fail

Daylight Saving Time is where 90% of agent time-math fails:

Scenario	Wrong Answer (no Time MCP)	Right Answer (with Time MCP)
2026-07-06 14:30 NY → Tokyo	+13h → 03:30 next day	+13h → 03:30 next day (both DST) ✓
2026-01-06 14:30 NY → Tokyo	+13h → 03:30 next day	+14h → 04:30 next day (NY is EST, Tokyo isn't DST) ✓
2026-03-29 14:30 (just before US DST) → Berlin	+6h → 20:30	+6h → 20:30 (Berlin already in CEST) ✓
2026-11-01 14:30 NY → Berlin	+6h → 20:30	+5h → 19:30 (NY in EDT still, Berlin in CET) ✓

The transitions the agent gets wrong are exactly the ones that matter most: scheduling meetings across DST boundaries, computing SLA timestamps that span DST, billing cycles on the day DST changes. The Time MCP server gets all of these right because the IANA database gets them right.

The Docker Image: Zero-Install

Anthropic publishes the Time MCP server as an official Docker image:

docker run -i --rm mcp/time

The image:

• Has the IANA timezone database baked in (regularly updated)
• Runs on Python 3.12+
• Has no external dependencies
• Works behind the Docker MCP Gateway

For teams running MCP via the Docker Toolkit, this is a one-line addition to the profile:

docker mcp profile add-server dev-tools --server time

The agent instantly has the time primitive — useful for any workflow that mentions "today," "tomorrow," "last week," "this quarter," or any wall-clock time.

Facio Integration

{
  "mcpServers": {
    "time": {
      "command": "uvx",
      "args": ["mcp-server-time"]
    }
  }
}

Or via Docker:

{
  "mcpServers": {
    "time": {
      "command": "docker",
      "args": ["run", "-i", "--rm", "mcp/time"]
    }
  }
}

Facio's audit trail captures every Time MCP call with the tool, the timezone requested, and the result. This is foundational audit data — every other time-sensitive tool call in the system can be cross-referenced against the Time MCP call that grounded it.

For HITL workflows, the Time MCP server is invisible to the user — it's used autonomously by the agent to ground every time-relative statement. There's no destructive surface, so there's nothing to gate. The tool is unconditionally safe.

The interesting HITL pattern is time-anchored audit trails. For any operation that depends on "now" — scheduling, sla computation, billing cycle logic — Facio can record the Time MCP response alongside the operation. The audit trail shows: "Agent computed 'tomorrow's standup' using Time MCP response at 2026-07-06T14:32:18 UTC; standup scheduled for 2026-07-07T10:00:00-04:00."

Quickstart

# Option 1: uvx (recommended for Python-based environments)
uvx mcp-server-time

# Option 2: Docker
docker run -i --rm mcp/time

# Option 3: pip install
pip install mcp-server-time
python -m mcp_server_time

Configuration:

{
  "mcpServers": {
    "time": {
      "command": "uvx",
      "args": ["mcp-server-time"]
    }
  }
}

First prompts (the agent uses Time MCP automatically):

"Schedule a call for tomorrow at 2pm with the Berlin team"
"When does our São Paulo office open for a user in Tokyo right now?"
"How many days until end of quarter?"
"What time is it in our Singapore office?"

Use Cases

Cross-timezone scheduling: "Find a 1-hour slot tomorrow that works for NY, Berlin, and Tokyo teams." Agent uses Time MCP to ground the dates, computes timezones correctly, finds the overlap window.

SLA computation: "Compute the time remaining on the customer support SLA — it started 4 hours ago at 2026-07-06T10:30 UTC." Agent uses Time MCP for "now," computes the diff, returns the formatted SLA status.

Business hours reasoning: "It's Monday 4pm — is the Berlin office open?" Agent gets current time + Berlin timezone + checks business hours.

Quarterly/weekly reasoning: "What's the date next Thursday for our standup?" Agent gets "now," computes Thursday.

Date format normalization: "Convert 07/06/2026 to ISO 8601." Agent uses Time MCP to validate, formats with timezone.

Time-anchored audit trails: Every Facio operation that mentions "now" or "today" is anchored to a Time MCP call.

Historical timezone math: "I have a timestamp 2025-01-15T14:30:00 from Brazil. What was the equivalent UTC?" Agent uses IANA database for Brazil pre-DST abolition rules.

Meeting notes with explicit timestamps: "Take notes for this meeting. For each action item, capture who, what, and the agreed-upon due date as a full ISO 8601 timestamp."

Email send-time optimization: "When is the optimal time to send the marketing email for recipients in Berlin, NY, and Tokyo?" Agent computes per-zone optimal time.

Cutoff time enforcement: "This campaign ends on Sunday at midnight UTC. How many minutes until then?" Agent computes the deadline.

Birthday / anniversary messaging: "Send a happy birthday email to everyone in our CRM whose birthday is today." Agent iterates the CRM, uses Time MCP to check "today's date."

Routine data cleanup: "Find all records older than 90 days." Agent uses Time MCP to anchor "now," computes the cutoff.

Calendar API augmentation: "List all my events for tomorrow, sorted by start time, formatted with each event's local timezone." Agent reads calendar + uses Time MCP for zone context.

Distributed-team coordination: "Which of our offices are open right now? When does each one close?" Agent iterates zones, computes for each.

Compliance windows: "Generate a report on transactions from the last 90 days for our compliance team." Agent uses Time MCP to anchor the 90-day window.

The "Always On" Pattern

The Time MCP server is unique in the ecosystem — it's one of the few MCP servers you should always have running, regardless of the task. The reason:

• Every workflow that mentions "today" or "now" needs it
• Every cross-timezone operation needs it
• Every SLA / deadline computation needs it
• Every audit trail benefits from it

The cost is trivial — two read-only tool calls, microsecond response times, no external state. The benefit is universal — every other tool's output becomes reliably time-anchored.

For any agent deployed in production, the Time MCP server is the baseline infrastructure. Include it in the default profile, every time.

Bottom Line

The Time MCP Server is the ground-truth time primitive for AI agents in 2026. Two tools (get_current_time, convert_time), IANA timezone database, DST-aware, ISO 8601 output, MIT-licensed, official Anthropic-maintained. The small surface that eliminates the "today is Tuesday" hallucination class.

For any agent that handles time-sensitive workflows — scheduling, SLA computation, business hours, cross-zone collaboration, deadline enforcement, date-relative reasoning — this is the foundational tool. The agent doesn't trust its own clock; it calls the tool and reasons on top of the response.

For the broader MCP ecosystem, the Time MCP server is the design lesson every "ground-truth primitive" MCP server should copy. Some operations are deterministic; some are statistical. Time is deterministic. Don't make the agent guess "now." Don't make the agent compute DST. Don't make the agent hardcode offsets. Provide the ground truth and let the agent reason on top.

uvx mcp-server-time (or docker run -i --rm mcp/time) and your agent has reliable time.

---

MCP Spotlight is a series covering servers that give AI agents real capabilities. Every server is evaluated for design clarity, ecosystem impact, and integration fit with Facio's HITL-first agent runtime.