# Morning Routine Builder is a scheduling engine. AI Agent Connect

> Morning Routine Builder uses backward scheduling logic to figure out your exact morning timeline. Instead of guessing how much time you need, you provide your departure time and a list of tasks. The MCP calculates exactly when you need to start each activity, accounts for task dependencies, and builds in safety buffers so you aren't rushing out the door.

## Overview
- **Category:** productivity
- **Price:** Free
- **Endpoint:** https://edge.vinkius.com/vk_preview_tsLqCN1dVoq5UR8Ewo5tfyRVlz3IixBnZQBTrOza/ai-agent-connect
- **Tags:** routine, scheduling, time-management, productivity, planner

## Description

You shouldn't have to do mental math every morning just to make sure you aren't late. This MCP handles the heavy lifting by working backward from your fixed departure time. If you need to leave by 8:00 AM, it calculates every preceding step, including the time needed for showering, eating, and getting dressed. It doesn't just add up minutes; it respects the order of operations. If you can't eat breakfast until after you shower, the engine accounts for that sequence. You can also adjust your safety buffers to see how much extra sleep you can grab without missing your window. It's a way to turn a vague list of chores into a precise, actionable timeline that your AI client can manage for you.

## Tools

### calculate_buffer_impact
This tool shows you how much extra sleep or free time you gain by shrinking your safety buffer or cutting optional tasks.

### get_task_metadata
Use this to pull specific details, like duration or requirements, for a single task in your routine.

### validate_dependencies
This tool checks your task order to ensure your proposed schedule is actually possible and has no logical conflicts.

### generate_routine
This tool builds your entire morning timeline based on your target departure time and your list of tasks.

## Prompt Examples

**Prompt:** 
```
Generate a routine where I need to leave at 08:00. Tasks: Shower (15m), Breakfast (20m, depends on Shower), Get Dressed (10m, depends on Shower). Include a 5 minute buffer.
```

**Response:** 
```
To leave at 08:00 with a 5-minute buffer, you should wake up at 07:10. Your timeline is: Shower at 07:10, Breakfast at 07:25, and Getting Dressed at 07:45.
```

**Prompt:** 
```
How much extra sleep can I get if I remove my 10-minute buffer?
```

**Response:** 
```
Removing the 10-minute buffer gives you exactly 10 minutes of extra sleep.
```

**Prompt:** 
```
What are the details for the 'Shower' task?
```

**Response:** 
```
The Shower task takes 15 minutes and is a mandatory task.
```

## Capabilities

### Backward Scheduling
Your agent calculates start times by working backward from your departure goal.

### Dependency Mapping
The MCP ensures tasks happen in the correct logical order.

### Buffer Management
Your agent can adjust safety margins to optimize for more sleep.

### Conflict Detection
The tool identifies if your requested task sequence is physically impossible.

## Use Cases

### Maximizing Sleep
You can see how much time you'd save by removing a buffer or an optional task like reading the news.

### Strict Commutes
You can build a timeline around a hard departure time to ensure you never miss a train.

### Complex Routines
You can manage routines with multiple dependencies, like needing to dry hair before leaving.

### Routine Auditing
You can check if your planned morning is actually possible before you try it tomorrow.

## Benefits

- Calculates exact wake-up times based on departure goals.
- Accounts for task sequences so you don't try to eat before you shower.
- Quantifies exactly how much sleep you gain by adjusting buffers.
- Prevents scheduling conflicts through dependency validation.

## How It Works

Connect the MCP to your AI client and start scheduling.

1. Connect the MCP to Claude, Cursor, or Windsurf via Vinkius.
2. Tell your agent your target departure time and your list of tasks.
3. The MCP runs the backward scheduling logic to build the timeline.
4. Review the generated schedule or adjust buffers to optimize your time.

## Frequently Asked Questions

**How does this MCP calculate my schedule?**
It uses backward scheduling logic. It starts at your departure time and works backward through your tasks and buffers to find your necessary wake-up time.

**Can I include tasks that must happen in a certain order?**
Yes. The MCP handles task dependencies to ensure your timeline follows a logical sequence.

**What happens if my schedule is impossible?**
The validation tool checks for logical conflicts and will identify if your proposed dependencies cannot work.

**How do I get more sleep using this tool?**
You can use the buffer impact tool to see how much time you gain by reducing your safety buffer or removing optional tasks.

**Which AI clients can I use this with?**
You can use this MCP with any compatible client, including Claude, Cursor, and Windsurf.

**How does the scheduling work?**
The engine uses backward scheduling. It starts at your departure time and subtracts the duration of each task and any required buffers to find the latest possible wake-up time.

**Can I include optional tasks?**
Yes, you can use the `includeOptional` parameter in `generate_routine` to decide whether to include tasks marked as optional in your timeline.

**How do I check for errors in my schedule?**
You can use the `validate_dependencies` tool to check if your task dependencies are logically possible and free of circular conflicts.