Procrastitask

Overview

Procrastitask is a consumer iPhone app for the obligations you keep putting off. It does two things no incumbent does together: it escalates a reminder until the task is closed, and it lets a partner or roommate own the task so the app does the nagging instead of a person. I built all of it: the escalation engine, the API, the client, the native alarm module, the brand, the store listing, and the launch.

• The server owns the clock: a per-minute sweep drives every timeline, so the phone is never the timer. Close the app or restart the device and the ladder still advances
• Escalation is completion-gated: nothing expires quietly. A task stops nagging when it is done, snoozed, or explicitly dropped, and completing it pulls back every pending alert
• Sharing requires consent: an assigned task is a request until the owner accepts it, so nobody gets nagged by a task they never agreed to
• Agents get a real surface: a hosted MCP server with 15 tools lets a user point Claude Code at their own account and create, edit, and close tasks as themselves

Problem

The reminder market splits into two camps, and nobody has merged them. The apps that nag you well cannot share at all. The ones that share remind everybody, which holds nobody to anything.

The gap is narrow and specific: owner-assigned tasks, escalating nags aimed only at the owner, and a signal back to the assigner on a miss or a completion, inside something that behaves like a task manager rather than an alarm clock.

The escalation ladder

The engine is ported from Hestia, my own assistant system, where the three-tier ladder had already been running against real tasks before any of this was a product. A task that passes its due time enters the ladder, rises with how long it has been overdue, and rolls forward at the top tier until someone closes it.

Every stage is per-task adjustable, and the whole ladder is instrumented on nudges-per-completion so the defaults can be tuned from real behavior.

The parts that took the longest

• Two modes. Every task is either escalate or notify_once. An informational reminder fires once and closes. Applying persistence indiscriminately is the single loudest complaint against the apps in this category, and it is how you get uninstalled in a week
• Snooze is a real state. Snoozing resets the ladder to stage 0 and preserves the due date, so escalation resumes gently rather than picking up where it left off
• Silencing has to equal closing. AlarmKit does not fire its Stop intent on a swipe-away, so acknowledgement is routed through custom Done and Snooze buttons. A swipe is treated as "not done, keep going"
• Escalation advances on absence. iOS gives no guaranteed delivery receipt, so the ladder never waits for a positive "delivered" signal that does not exist. It advances on the absence of a completion

Shared accountability

The sharing model is the reason the app exists, and it is where most shared-list products get the invariants wrong. Consent is enforced in the data, not in the UI.

Agent-native access

Plenty of reminder apps have an API. Almost none are built for someone else's agent to drive. Procrastitask ships a hosted MCP server as a product surface of its own, so a user can point Claude Code at their own account and have it file and close obligations on their behalf.

claude mcp add --transport http procrastitask \
  https://api.procrastitask.app/mcp \
  --header "Authorization: Bearer pk_..."

An agent can take an obligation off your plate, but a person still has to do the thing. The escalation engine is what turns an agent's reminder into follow-through.

Architecture

Python 3.12 and FastAPI on AWS App Runner, backed by Neon Postgres, behind a branded API domain. The client is Expo and React Native with one Swift native module for AlarmKit.

A green health check is not proof the app is whole

The Docker image installed dependencies unpinned at build time, so its contents were a function of the build date rather than the commit. When a dependency moved an import in a major release, the MCP mount failed inside a caught ImportError and agent access went down for six days while /health stayed green the whole time. The fix was three-part: lock every dependency so the image follows the commit, refuse to boot in the cloud when the mount fails, and smoke-check the actual /mcp surface on every deploy. Probe the feature, not the process.

Working when the app is closed

The home-screen widget and the Live Activity stayed current only for people who opened the app most days. The widget snapshot was written by a foreground sync, with a background task as the sole fallback, and iOS budgets those by how much you use the app. The server could start a Live Activity but had no way to update or end one. Both are the wrong failure mode for an app whose promise is that it keeps working when you are ignoring it.

• Every push now carries the snapshot. A Notification Service Extension writes it into the shared App Group with no app runtime and no background budget
• Live Activity update and end pushes ramp a card through the stages and dismiss it on completion, using a per-activity token distinct from the one that starts it
• The widget builds a multi-entry timeline, so a task appears at its due minute with no push involved at all
• A silent push covers the rest: changes with no alert to ride on, like a task created on another device or filed by an agent over MCP

Getting the alarm right

A real user got a full-screen breakthrough alarm at 1am for an ordinary task. An app that does that deserves to be deleted, so it got a three-auditor adversarial pass rather than a patch.

The audit cleared the server: the ladder, the notify-once mode, the assigner loop scoped to the assigner's own timezone, and the daylight-saving math were all sound. The gap was on-device alarm invalidation, which is a different bug than the one the symptom pointed at.

Must-not-miss tasks keep ringing through a pause by default, because the reason someone pauses is usually medical and the thing they marked must-not-miss is usually medication.

Shipping it

I do not own a Mac. Every iOS build runs in the cloud on EAS and installs on a physical iPhone, which rules out the simulator as a debugging surface and makes each build expensive enough that batching them is a real constraint on how the work is sequenced.

CI that fails honestly

For most of the build there was no pull-request CI while main auto-deployed to production. Every pull request now runs lint, the full server suite against a Postgres service container, and a mobile typecheck. The suite skips database-backed tests when Postgres is unreachable, so the workflow asserts connectivity and fails on any skip. A green run that quietly skipped everything is worse than no CI at all.

Outcomes

Delivered capabilities

Building something agents can actually drive?

Procrastitask is what it looks like to treat an agent as a first-class client of a consumer product: one service layer, one set of invariants, scoped tokens a user can revoke, and a human-facing app that does not degrade because the agent surface exists. If you are putting an MCP surface on a real product, I would like to hear about it.