2025 Growth Unified Hits Major Growth Milestones with 6.5x usage & 4.5x revenue growth
Unified.to
All articles

Calendar & Meetings MCP Servers: Real-Time Scheduling Actions for AI Agents

February 20, 2026

Modern SaaS products don't just display meeting data. They schedule meetings, retrieve context, update details, analyze availability, and increasingly — act on calendar events directly.

If your product embeds AI features that depend on scheduling data, you need authorized reads and writes across Google Calendar, Microsoft Outlook, Microsoft Teams, Zoom, Calendly, and others — without building and maintaining each integration separately.

This is where Calendar & Meetings + MCP come together.

Unified's Calendar & Meetings category provides a normalized, real-time API across supported providers. Unified MCP allows LLMs to call those calendar operations as structured tools.

This post explains:

  • What Calendar & Meetings MCP is
  • What tools and objects are available
  • Recurring event and attendee support
  • Provider variability
  • Rate limits and execution behavior
  • Model tool limits
  • When to use the Calendar API vs MCP

AI-Native Calendar Use Cases

Calendar & Meetings MCP enables:

Schedule Meetings

  • Create events
  • Add attendees
  • Configure recurrence

Find Availability

  • Retrieve free/busy
  • Analyze time windows

Update Event Details

  • Modify title
  • Update time
  • Adjust attendees
  • Change recurrence

Retrieve Past Meetings

  • List historical events
  • Expand recurring series
  • Retrieve recordings (where supported)

These features can be embedded directly into SaaS products without building separate integrations per calendar provider.

What Calendar & Meetings MCP Is

Calendar & Meetings MCP is the structured tool-calling layer built on top of the Unified Calendar & Meetings API.

In our architecture:

  • The Calendar & Meetings category defines normalized objects such as:
    • Calendar
    • Event
    • Busy (availability)
    • Link
    • Recording
    • Webinar
  • Each object exposes documented operations via the unified API.
  • The MCP server sits on top of that API.
  • Each tool call maps to one API request.
  • Each request is routed directly to the connected provider.

Execution path:

User → LLM → Calendar tool call → Unified Calendar API → Source platform

There is no caching layer.

There is no stored calendar database.

Each tool call executes against the live state of the connected system at the time of execution.

Unified Calendar & Meetings Objects and Operations

The OpenAPI specification defines the following objects and operations:

Calendar

  • Create
  • List
  • Retrieve
  • Update (PUT)
  • Patch (PATCH)
  • Delete

Event

  • Create
  • List
  • Retrieve
  • Update (PUT)
  • Patch (PATCH)
  • Delete

Busy (Free/Busy)

  • List only
  • Create
  • List
  • Retrieve
  • Update
  • Patch
  • Delete

Recording

  • List
  • Retrieve

Webinar

  • Create
  • List
  • Retrieve
  • Update
  • Patch
  • Delete

Not every integration exposes every object or every operation. Tool availability depends on provider feature support and connection permissions.

Recurring Events Support

Recurring events are part of the unified data model.

The CalendarEvent object includes:

  • recurring_event_id
  • recurrence configuration

The recurrence schema supports:

  • Frequency: DAILY, WEEKLY, MONTHLY, YEARLY
  • Interval
  • Count
  • End date
  • Specific day/month/week/year constraints
  • Inclusion and exclusion dates

Recurring patterns can be created and updated where the provider supports event updates.

When listing events, the expand parameter allows recurring series to be flattened into individual instances. This is especially useful for availability analysis and historical meeting summaries.

Attendee and RSVP Support

The unified attendee model includes:

  • Attendee objects
  • status field with enum values:
    • ACCEPTED
    • REJECTED
    • TENTATIVE

The event model allows attendees to be updated where provider event updates are supported.

This enables AI features such as:

  • Modifying attendee lists
  • Updating RSVP status
  • Coordinating availability-based scheduling

Free/Busy Availability

Availability is accessed through a unified endpoint:

/calendar/{connection_id}/busy

This provides normalized free/busy data across providers.

Busy endpoints are read-only and support time filtering, limit, and offset parameters.

AI use cases include:

  • Finding availability
  • Conflict detection
  • Suggesting meeting times

Provider Variability

Calendar integrations vary significantly in write support.

Some providers support full CRUD for events (create, update, delete).

Others are read-only for events.

Examples:

  • Google Calendar, Microsoft Outlook, Microsoft Teams support event create/update/delete.
  • Some providers expose only list/get for events.
  • Certain integrations support webinars or bookings but not general event mutation.
  • Some integrations do not expose event deletion.
  • Recurring event modification depends on provider support for event updates.

Write operations must always be scoped as 'where supported.'

Rate Limits and Execution Behavior

Each Calendar MCP tool call executes directly against the source API.

This means:

  • Provider rate limits apply.
  • High-frequency scheduling updates may trigger throttling.
  • Bulk listing operations should be paginated.
  • Retry and backoff logic should be implemented for 429 responses.

Because execution is pass-through:

  • Updates persist immediately in the source platform.
  • There is no intermediate storage.
  • There is no delayed sync.

Calendar API vs Calendar MCP

Both use the same underlying real-time Calendar API.

The difference is who determines which operation to execute.

Use the Calendar API directly when:

  • Your backend controls scheduling logic.
  • You build availability dashboards.
  • You generate analytics over meeting history.
  • You persist derived state or embeddings.

Execution:

App → Unified Calendar API → Source platform

Use Calendar MCP when:

  • The LLM decides which calendar action to execute.
  • You are embedding AI scheduling assistants inside your product.
  • You need structured function-calling.
  • You want to restrict tool access via scoped permissions.

Execution:

User → LLM → Tool call → Unified Calendar API → Source platform

The infrastructure remains the same.

The decision-maker changes.

Model Tool Limits

Current model limits:

  • Groq: up to 10 tools
  • OpenAI: up to 20 tools
  • Cohere: up to 50 tools

Calendar integrations expose varying tool counts depending on objects supported.

You should restrict the tool surface using:

  • permissions
  • tools
  • defer_tools

Tool restriction is required for production deployments.

Build Real-Time Scheduling Agents

With Calendar & Meetings MCP, your agents can:

  • Create meetings
  • Modify recurring events
  • Update RSVP status
  • Retrieve availability
  • Act across Google Calendar, Outlook, Teams, Zoom, Calendly, and others

Each action executes directly against the connected provider.

No caching.

No sync layer.

No stored calendar replica.

Start building with Unified MCP

  • Enable Calendar integrations
  • Restrict tool surface per model
  • Connect Google Calendar, Outlook, Zoom, and others
  • Ship AI-driven scheduling features inside your product

→ Start your 30-day free trial

→ Book a demo

All articles