Village

Village turns shift changes and childcare gaps into one visible, confirmed family plan—with WebMCP agents coordinating and families keeping control.

Comment

Inspiration

Village was not created for this competition.

I have been thinking about this idea ever since those adverts years ago that said, "There's an app for that." The problem I have faced is a lack of technical knowhow.

I have always been terrible at keeping up with schedules. That was true when I was single, and it is definitely true now that I have children and both my partner and I work shifts. My partner and I currently work as Police Officers in the UK, we are on different teams so have different shift patterns. We rely heavily on family for childcare and there have been a few occasions where we have completely forgot or got confused and its ended up in one of us having to take emergency leave.

Our weeks can include early shifts, late shifts, nights, overtime (sometimes planned, often spontaneous), school, childcare, appointments, pickups and drop-offs. One small change can throw everything else out. We end up checking calendars, messaging relatives and trying to work out who is available—all while hoping we have not forgotten something.

The idea for Village has always been there. The know-how to build it had not.

AI changed that for me.

It gave me the ability to take an idea I had carried around for years and turn it into a real, working product. The competition did not create Village, I have been toying with how the idea would work for years. However, it did give me the push—and the technology—to take it much further.

Village turns the mess of family life into one visible, shared plan.

The demo begins with a completely normal situation in our house: I accept an overtime shift on Tuesday.

Village adds the overtime, compares it with my partner's shift and identifies that our children now need childcare. It then proposes an ordered Relay: Anne first, Grandad second and Claire third.

I approve the complete plan before anybody is contacted. Only one person is approached at a time.

Anne declines, so Village moves on to Grandad. Grandad accepts, the Relay stops immediately and Claire is clearly shown as Not contacted.

That last part matters. I did not want to build something that messages everybody at once and leaves several relatives arranging the same childcare.

Village should reduce noise and stress—not create more of it.

It also supports:

  • rota scans with shifts reviewed before import;
  • repeating patterns such as six days on and four days off;
  • irregular multi-week rotas where every week is different;
  • early, late and overnight shifts;
  • one-off exceptions and overtime;
  • automatic childcare-gap detection;
  • trusted carers and their availability;
  • a visible history of important actions.

Village was designed around my family, but the problem is not unique to us. Millions of shift-working families are trying to manage the same thing through screenshots, group chats and memory.

How we built it

Village is a responsive React and TypeScript application with four connected WebMCP tool surfaces.

The visible interface and the agent tools use the same state-transition engine. Whether I press a button or ask an agent to act, the result goes through the same rules.

Village is not just a chatbot with calendar information pasted into it. The website exposes 24 page-defined WebMCP tools that act on the same family plan visible on the screen.

The tools cover four connected areas:

  • Family Schedule — reads the shared plan, adds approved overtime and identifies childcare gaps.
  • Village Relay — creates an ordered childcare chain, records responses and stops when somebody accepts.
  • Rota Scan — prepares scanned shifts, flags anything uncertain and imports them after approval.
  • Shift Patterns — creates flexible rota cycles, handles exceptions and changes future shifts without rewriting the past.

Without WebMCP, an agent would be clicking around a webpage or working from an outdated copy of the calendar.

With WebMCP, Village defines exactly what the agent can do, what information it needs and when it must stop for confirmation.

The agent is good at:

  • reading across the complete family plan;
  • spotting clashes and missing childcare;
  • checking which trusted carers are suitable;
  • continuing a process that has already been approved;
  • explaining what changed.

The family still controls:

  • changes to the calendar;
  • who may be contacted;
  • the order in which people are approached;
  • the response window;
  • the final childcare arrangement.

Before Village changes a commitment or contacts somebody, it explains the exact action and asks for confirmation.

Once I approve a Relay, the agent can continue inside that boundary without repeatedly asking the same question. It cannot quietly change the order, expand the plan or contact everybody at once.

The agent handles the coordination. The family keeps the decisions.

Underneath the interface are:

  • stable identifiers for shifts, patterns, requests and responses;
  • shared household revisions that prevent stale approvals;
  • idempotency keys that prevent duplicate actions;
  • confirmation gates tied to the exact proposed change;
  • interval-based scheduling and childcare-gap detection;
  • machine-readable errors;
  • an auditable history;
  • responsive phone, tablet and desktop layouts.

The public competition build uses demonstration data and requires no account, allowing judges to test the complete flow immediately.

The final build passes 72 automated tests, including duplicate responses, stale plans, mismatched retries, malformed shift times, overnight work and repeating-pattern changes.

Challenges we ran into

The hardest part was not registering a WebMCP tool.

It was keeping one coherent family plan while both a person and an agent could change it.

The other difficult question was how much freedom the agent should have.

A request such as "sort the childcare" sounds simple, but it could easily result in an agent messaging everybody, duplicating requests or making assumptions about who should look after somebody's children.

Village turns that broad request into a clear plan containing:

  • named carers;
  • a specific contact order;
  • a response window;
  • an approval boundary;
  • an immediate stop when somebody accepts.

Supporting real shift patterns was another challenge. Rotas are rarely as neat as normal calendar applications expect.

Village needed to support short repeating cycles, six-week patterns where every week is different, overnight shifts, individual exceptions and future changes without silently altering previous commitments.

We also tested the uncomfortable edge cases: stale approvals, duplicate responses, retries, conflicting identifiers and events that cross midnight.

Family coordination involves real people, so silently doing the wrong thing was not acceptable.

Accomplishments that we're proud of

I am proud that Village solves a problem from my actual family life rather than inventing a problem for a competition.

I am also proud that:

  • the WebMCP tools complete an end-to-end coordination task, rather than demonstrating isolated commands;
  • agent actions and direct interface actions share one visible source of truth;
  • confirmation represents meaningful consent rather than decorative friction;
  • retries do not create duplicate shifts or childcare requests;
  • the Relay shows both who was contacted and who was deliberately left alone;
  • irregular and overnight shift patterns are handled properly;
  • the complete build passes 72 automated tests;
  • the interface works across phones, tablets and desktops;
  • Village remains useful as a family product even when no agent is involved.

The moment Grandad accepts, the Relay stops, the calendar updates and Claire remains Not contacted.

That single screen demonstrates the whole idea: useful autonomy operating inside a boundary the family approved.

What we learned

I learned that the best agent experiences do not replace the interface. They make the shared interface more useful.

The family should be able to see what the agent sees, understand what it proposes and verify what happened afterwards.

WebMCP forced me to think carefully about:

  • the smallest meaningful actions;
  • the information each action needs;
  • what the agent can safely continue doing;
  • the moments where human consent matters.

That produced a calmer and more accountable product than simply giving an agent permission to click around a calendar.

I also learned that AI can completely change who gets to build software.

I did not suddenly have this idea because generative AI became available. I had the idea for years.

AI closed the gap between having the idea and being capable of turning it into something real.

What's next for Village

The competition build proves the core idea, but I want Village to become a real product that my family can genuinely use.

The next version would add:

  • private household accounts and permissions;
  • direct Outlook and Google Calendar integration;
  • real-time invitations and carer responses;
  • push notifications with simple yes-or-no actions;
  • voice notes and thank-you messages;
  • school-calendar integrations;
  • live traffic and public-transport delays;
  • employer rota integrations;
  • stronger privacy controls for family information.

The larger vision is a trusted coordination layer for families, friends, neighbours and carers.

Family life will probably never be simple. Village can at least make organising it feel simple.

Built With

Share this project:

Updates

Submission history