lifeline

About Lifeline

Lifeline is a Slack-native coordination agent that turns messy aid requests, supply updates, and volunteer availability into private, trackable handoffs that do not silently fail.

Nonprofit and public-good teams often coordinate urgent support inside chat: someone posts that a family needs supplies, someone else mentions that items are available, and a volunteer says they might be able to deliver. The problem is that these “warm handoffs” can easily fall through the cracks. A responder may not confirm, private details may be exposed in public channels, or everyone may assume someone else has taken ownership.

Lifeline was inspired by that coordination gap. We wanted to build an agent that does not just summarize Slack messages, but actively helps a team move from need → match → assignment → private handoff → completion.

What it does

Lifeline monitors a Slack workspace for operational signals across channels such as:

#aid-requests
#available-supplies
#volunteer-dispatch
#case-notes
#urgent-gaps

It classifies messages into aid requests, supply signals, responder availability, case notes, and gaps. From there, Lifeline builds a live coordinator dashboard showing which cases are ready to assign, which need escalation, which are in progress, and which have been completed.

A typical workflow looks like this:

A responder shares availability in natural language, such as:
“I’m available in Banjara Hills tonight from 1am to 6am with a car and can deliver diapers and milk bottles.”
A coordinator posts an aid request and supply update in Slack.
Lifeline matches the need, supply, and responder.
The coordinator explicitly clicks Assign.
The responder receives a private assignment preview.
Private handoff details are only released after the responder accepts.
Lifeline sends a mission timeline with progress buttons.
Safe updates are posted back to #case-notes.
The after-action report shows what was assigned, accepted, completed, or still needs backup.

This keeps sensitive details out of public channels while making the handoff auditable.

How we built it

Lifeline is built as a Slack Bolt app in Node.js and TypeScript, running through Slack Socket Mode. The backend handles slash commands, Slack message events, Block Kit buttons, App Home onboarding, responder DMs, and coordinator dashboards.

The main system components are:

Slack event ingestion for real-time channel messages.
AI availability normalisation to convert messy responder text into structured availability.
Deterministic safety checks for required fields like location, time window, support type, capacity, and privacy risk.
Location resolution for Indian cities and neighbourhoods, such as Banjara Hills, Hyderabad and Velachery, Chennai.
Matching logic to compare needs, supplies, responders, time windows, location, support type, and capacity.
Private handoff flow where responders receive a safe preview first, and private details only after acceptance.
Mission timeline buttons for start, pickup, resource collection, beneficiary arrival, and completion.
Neon PostgreSQL for users, responder profiles, cases, dossiers, handoff responses, supply reservations, and timeline events.
MCP server integration for operational reasoning, including route risk, match completeness, and case risk.

The matching score is based on factors like location, resource fit, time compatibility, and responder capacity. Conceptually, the score follows:

[ Score = w_lL + w_rR + w_tT + w_cC + w_sS ]

where (L) is location fit, (R) is resource fit, (T) is time compatibility, (C) is capacity, and (S) is support-type match.

Challenges we faced

The hardest part was making Lifeline behave like a real operations system instead of a simple chatbot.

One challenge was state management. Early versions of the dashboard accidentally changed state just by being opened. We had to separate read-only coordinator views from explicit actions like assigning a responder. That made the product safer and more predictable.

Another challenge was lifecycle syncing. When a responder completed a handoff, the system had to update not just Slack messages, but also the case state, dashboard, report, and timeline records. This forced us to think carefully about every status transition.

We also had to handle messy human input. Volunteers might say “I can help near Hyderabad later” or “weekdays 4pm to 8pm, got car.” Lifeline had to ask clarifying questions when information was incomplete, but also avoid being too rigid.

Privacy was another major challenge. Public-good coordination often includes sensitive details like phone numbers, exact addresses, health needs, or identity information. Lifeline was designed so public channels only receive safe operational updates, while private handoff details are shared only after the responder accepts.

What we learned

We learned that useful AI agents are not only about generating text. In this project, the agent had to manage state, permissions, trust, privacy, and real-world operational follow-through.

We also learned the importance of designing for failure. A handoff is not complete just because someone says they can help. Lifeline needs to know whether the responder accepted, whether the mission started, whether the resource was picked up, and whether the handoff was completed.

Most importantly, we learned that in high-stakes coordination, the agent should not replace the human coordinator. It should make the coordinator’s work safer, clearer, and harder to lose.

What’s next

Next, we would improve Lifeline with richer multi-responder backup routing, stronger location-aware ETA calculations, recurring volunteer schedules, and organisation-level analytics. We would also add more configurable privacy policies so different nonprofits can decide what information should always stay private.

Our long-term goal is for Lifeline to become a lightweight operations layer for public-good teams that already live in Slack: helping them coordinate urgent support without losing ownership, privacy, or accountability.