Relay

relay_system_architecture
relay_responsibility_xray_lifecycle
relay_atomic_ownership_transfer
relay_core_domain_persistance_model
relay_judgemode_endtoend_story

Inspiration

The idea for Relay came from a small but common problem. Someone can say, “I’ll handle it,” but somehow you are still the one remembering the date, checking if it is done, following up, and reminding them. That made us think about the difference between doing a task and actually owning a responsibility. Most shared task apps move the visible task. They do not move all the invisible work around it. Relay was built around that missing piece.

What it does

Relay helps people hand over a responsibility completely. You can write something simple like: “Can you take care of Maya’s dentist appointment next month?”

Relay breaks that into the hidden work behind it, such as planning, deciding, preparing, doing, checking, following up, and handling anything that repeats. Before the responsibility changes hands, the new owner sees exactly what they are agreeing to take over. Once they accept, Relay moves the ownership and the future reminders with it. Our main rule is called No Boomerang. After a responsibility is transferred, Relay should not quietly start reminding the old owner again. The goal is simple: if you handed something over, you should be able to stop carrying it in your head.

How we built it

We built Relay as a real responsibility engine rather than a task-list demo. The backend is built with Python, FastAPI, PostgreSQL, SQLAlchemy, and Alembic. Responsibilities have real owners, lifecycle steps, ownership versions, recurring cycles, reminders, and an audit history. Ownership transfer is handled as an atomic transaction. The receiver has to accept the handoff before anything changes. When that happens, Relay changes the owner and reroutes future reminders together so the system does not end up in a half-transferred state. A durable worker handles scheduled reminders and recurring responsibilities. We also built in-app notification support and an external notification path. AI is used only where it is useful. It turns normal language into a structured Responsibility X-Ray. It can suggest hidden steps and assumptions, but it cannot assign an owner or change responsibility by itself. The user stays in control. The frontend turns all of this into one visual idea called the Ownership Thread, so a responsibility can actually be seen moving from one person to another.

Challenges we ran into

The hardest part was realizing that changing an owner_id was nowhere near enough. A responsibility may already have reminders, future steps, recurring work, dependencies, and history attached to it. All of that has to remain correct when ownership changes, including when two actions happen at nearly the same time. We also had to be very careful with AI. It is easy to make an impressive demo where a model invents a perfect list of hidden tasks. It is much harder to build something that clearly separates what the user actually said from what AI only inferred. Another challenge was making the idea visible. “Mental load” can become very abstract very quickly. We had to design the product so a judge could actually see the hidden work appear and then see it leave the original owner after a handoff.

Accomplishments that we're proud of

The part we are most proud of is that Relay is not just pretending to transfer responsibility in the interface. The ownership rules live in the backend. The No Boomerang rule is enforced at the system level, not just by hiding something from the screen. Ownership changes, reminder routing, recurrence, and audit history all work together. We are also proud of the Responsibility X-Ray because it gives AI a narrow, useful job without giving it control over people. And finally, we like that Relay does not try to score relationships or decide whether someone is being “fair.” It focuses on something much more concrete: who owns this responsibility now, and who should have to remember what happens next?

What we learned

We learned that a lot of invisible work is not really about completing tasks. It is about keeping open loops in your head. That changed the way we thought about the whole product. We also learned that good AI does not always mean giving the model more control. In Relay, some of the strongest parts are deterministic rules around consent, ownership, reminders, and recurrence. The AI helps reveal the structure. The system rules protect it.

What's next for Relay

The next step is making Relay easier to fit into everyday life. We would like to connect it with calendars and email so responsibilities can be captured without manually rebuilding information people already have. We also want to improve recurring household responsibilities, backup ownership, private shared planning, and multilingual support. Longer term, we want Relay to become something quieter than another productivity app. The goal is not to help people manage more tasks. It is to help them genuinely let go of the responsibilities they no longer own.