# Household Chore Rotation AI Agent Connect

> Household Chore Rotation MCP manages your home's task list by weighing the difficulty of chores against each person's schedule. It uses effort points to ensure no one person gets stuck with all the heavy lifting. You can use it with any MCP-compatible client to generate weekly plans, check workload balance, and verify that tasks are rotating fairly among everyone in the house.

## Overview
- **Category:** productivity
- **Price:** Free
- **Endpoint:** https://edge.vinkius.com/vk_preview_kvyviesnMiS37QXnMy7SBK5kpbSXUn8xKFEAunto/ai-agent-connect
- **Tags:** chore, scheduling, household, rotation, management

## Description

Stop arguing about who did the dishes last. This MCP acts as a scheduling engine that treats household chores like a balanced workload. Instead of just listing tasks, it assigns them based on effort points and the actual availability of each resident. If someone is busy on Tuesdays, the system won't assign them the trash pickup that day. It tracks historical data to make sure the same person isn't always stuck with the hardest jobs. You can ask your AI client to build a full weekly plan, check if the workload is actually even, or find out why a specific chore didn't get assigned. It's a way to turn chore management into a data-driven process that everyone in the house can agree on.

## Tools

### get_unassigned_reasoning
This tool explains why certain chores were left unassigned. It identifies if availability conflicts or specific resident exclusions prevented a task from being scheduled.

### get_weekly_schedule
This tool generates a complete chore assignment plan for the upcoming week. It builds the schedule by looking at effort points and resident availability.

### validate_rotation_fairness
This tool checks if your current assignment plan is actually fair. It compares current tasks against historical data to ensure chores are rotating properly.

### get_resident_workload_balance
This tool analyzes how effort is distributed across the household. It calculates if the total effort points are evenly spread among all members.

## Prompt Examples

**Prompt:** 
```
Generate a weekly chore schedule for Alice and Bob.
```

**Response:** 
```
Alice is assigned: Vacuuming (5 pts), Dishwashing (3 pts). Bob is assigned: Trash (2 pts), Laundry (5 pts). Total effort: Alice 8, Bob 7.
```

**Prompt:** 
```
Is the workload balanced between the residents?
```

**Response:** 
```
The workload is well-balanced with a deviation score of 0.5, as Alice has 8 points and Bob has 7 points.
```

**Prompt:** 
```
Why wasn't the 'Mop Floor' chore assigned?
```

**Response:** 
```
The 'Mop Floor' chore was not assigned because all residents with availability during the required window have an exclusion for this task.
```

## Capabilities

### Effort-based assignment
Your agent uses effort points to weigh how much work each chore actually requires.

### Availability matching
The system checks resident schedules to ensure tasks are assigned when people are actually free.

### Workload auditing
Your AI client can calculate deviation scores to see if one person is doing more than others.

### Rotation verification
The MCP uses historical data to confirm that chores are cycling through residents fairly.

### Assignment troubleshooting
Your agent can identify specific reasons why a task remains unassigned.

## Use Cases

### Weekly Planning
Generate a full list of assignments for the week every Sunday night.

### Conflict Resolution
Use the unassigned reasoning tool to explain why a task wasn't picked up.

### Fairness Audits
Check the workload balance to see if one roommate is doing more than their share.

### Rotation Management
Verify that the heavy cleaning tasks are rotating through all residents correctly.

## Benefits

- Reduces household arguments by using objective effort points.
- Prevents burnout by monitoring resident workload balance.
- Automates scheduling based on real-time availability.
- Ensures long-term fairness through historical rotation tracking.

## How It Works

Connect the MCP to your AI client and let it handle the math of household management.

1. Connect the MCP to your preferred client like Claude or Cursor.
2. Provide your resident list, their availability, and chore effort points.
3. Ask your agent to generate a weekly schedule.
4. Use the agent to check for balance or rotation fairness as needed.

## Frequently Asked Questions

**How does the MCP decide who does which chore?**
It uses a combination of effort points for each task, the availability of each resident, and historical rotation data to ensure fairness.

**Can I use this with Claude or Cursor?**
Yes, you can connect this MCP to any MCP-compatible client including Claude, Cursor, and Windsurf.

**What if a chore isn't assigned to anyone?**
You can use the get_unassigned_reasoning tool to find out why, such as if everyone available has an exclusion for that specific task.

**How do I know if the chores are being split fairly?**
You can ask your agent to run the get_resident_workload_balance tool to see the distribution of effort points among residents.

**Does this track who did what in the past?**
Yes, it uses historical rotation data to validate that tasks are being distributed correctly over time.

**How does the system ensure chores are fair?**
The system uses effort points to balance the workload and `validate_rotation_fairness` to ensure tasks are distributed fairly over time.

**What happens if a chore cannot be assigned?**
Unassigned chores are reported, and you can use `get_unassigned_reasoning` to find out why they couldn't be allocated.

**Can I account for resident availability?**
Yes, the `get_weekly_schedule` tool incorporates resident availability and exclusions into the assignment logic.