Loopr Docs App →

People & Delegation

The premise

When you delegate something, it shouldn’t disappear. You need to know what’s outstanding, who owns it, and when to follow up. But it also shouldn’t clutter your main loop every minute — you delegated it so someone else would handle it.

Loopr solves this with a separate People domain (/people), a delegation-aware loop filter, and a per-person share link the delegatee can use to mark things done themselves.

People

The People page has two columns:

  • Org chart (left) — a collapsible tree of everyone you’ve added. Each person can be marked as reporting to someone else, so you can model multiple levels of an org or a household.
  • Detail panel (right) — for the selected person, shows their name, role, email, notes, share link, direct reports, and open delegations.

You can add anyone — direct reports, peers, cross-functional folks, external contacts. The tree is just for context; you can delegate to anyone regardless of where they sit in it.

Each person card in the tree shows a small badge with the count of open delegations assigned to them.

Delegating

Press d on any item in the loop to open the delegate modal:

  • Search by name or role
  • Check multiple people if you delegated to a group (“Alice, Bob, Carol all need to populate this spreadsheet”) — each person gets their own delegation row with independent status
  • Set a follow-up window (default 3 days; 0 = no reminder)
  • Optional notes

Cmd/Ctrl+Enter submits. Enter in the search field toggles the top match.

Each selected person gets their own delegation record on the item. Each one has its own status (open / done / blocked / handed back), follow-up date, and notes — so one person can be done while you’re still chasing another.

Re-delegating to defer

Press d again on a delegated item that’s resurfaced in your loop and adjust the follow-up window — the existing delegation gets its due_back extended in place rather than recreated. Useful for “give them another week” without losing the original delegated_at history.

Share links — let the delegatee mark things done themselves

Each person has a unique URL of the form https://loopr.life/d/<token>. Anyone with that URL can:

  • See every item you’ve sent their way.
  • See who else is working on the same item (“Also working on this: …”) and what those collaborators wrote when they finished — so they have full context without having to ask you.
  • Mark each one done with a free-form result note. The note appears back in your loop so you can read it without bouncing through email or Slack.

There’s no login. The token is the credential — anyone you share it with has access until you regenerate it. Treat it like any other shared link: send it directly, don’t post it publicly.

What the delegatee actually sees

Be explicit with yourself before you delegate: the item’s title and description are visible to the holder of the link. That includes the item titles for delegations they themselves are not on (only their own asks are listed, but every item title that lands in their list is shown verbatim).

For Loopr items that came in from a stream, the title is whatever the upstream system produced:

  • Gmail — the email subject line.
  • GitHub — the PR or issue title.
  • Linear — the issue / project / initiative title and any AI-generated description summarizing the thread.
  • Slack / Discord — the message snippet.

If something in there is sensitive, don’t delegate it via share link — or edit the item’s title and description first to scrub the parts you don’t want shared. The delegatee never sees who else has share links, your other items, or anything outside what was explicitly delegated to them.

To get someone’s link, open their detail panel: the Share link section has a Copy button. The Regenerate button creates a fresh URL and revokes the old one immediately — use it if a link leaks or someone leaves the org.

What happens when a delegatee marks something done

The result note ends up on the delegation row itself, never overwriting your item’s description. It surfaces in two places:

  • Below the description in the item edit form (press Enter on a delegated item to see it). Each delegate’s note is shown in its own block.
  • As context for AI summarization. Streams that re-summarize on each fetch (Gmail / GitHub / Linear) include past delegation results in the prompt, so the AI weaves them into the next description without ever touching the handwritten content.

What lands in your loop depends on whether other delegations are still open:

  • Other delegations remain — a new “Update from <Person>: <original title>” item appears in your loop with their notes as the description. The original delegated item stays hidden until everyone reports back.
  • They were the last one — the original item resurfaces in the loop on its own (the queued filter no longer hides it because no delegations are open). All result notes are visible in the edit form.

Completing the original item from your loop also closes any delegations still open on it — you don’t end up with stale “waiting on Alice” rows on something you finished yourself.

Agenda — collaborative talking-points list

Each person also has an Agenda section on their detail panel: a running list of things to bring up next time you sync. Useful for 1:1s, standups, or any recurring check-in where points pile up between conversations.

Both you and the person can write to it:

  • You add items from the People page. Nothing extra happens — they just sit on the agenda until you have your sync.
  • They can add items from their /d/<token> portal. When they do, a Loop item lands in your loop (“Agenda from <Person>”) so you see the new point as it comes in instead of only when you happen to open their detail panel.

Items are removed by you on the People page. There’s no due date, no priority, no status — it’s a shared notepad scoped to a single person.

Email notifications

Each person has an Email them when I delegate a task or add an agenda item checkbox on their detail form. Turn it on (and add an email address — the checkbox is disabled without one) and Loopr sends a short, plain transactional email to the person whenever:

  • you delegate an item to them, or
  • you add an agenda item for them from your People page.

Every email contains the original context (item title, description, delegation note, or agenda text) plus a “View on Loopr” button that deep-links to their /d/<share_token> portal — so they can mark delegations done or read the agenda without you having to send the link each time.

Notifications are best-effort: a failed delivery is logged but never blocks the underlying action. The portal-side person adding their own agenda item never triggers an email — only items you write for them.

The loop hides delegated items

Once an item has any open delegation, it leaves your main loop. It resurfaces automatically when one of its follow-up dates arrives, or when the last open delegation closes — the item comes back at its original loop position with a “→ Alice, Bob” badge.

If you set the follow-up window to 0 (“no reminder”), the item stays out of the loop indefinitely — you’re tracking it but don’t need a prompt.

Delegating clears the source notification

Delegating an item also clears it in the upstream system that produced it, so you don’t have to do that cleanup twice:

  • Gmail — the thread is archived (INBOX label removed).
  • GitHub — the notification is marked done.
  • Linear — the notification is archived.
  • Items from sources without a corresponding “clear” API (Google Calendar, iOS Reminders, scheduled streams, manually-created items) are unaffected in the source.

The Loopr item itself stays — only the upstream notification is cleared. Sync is delegation-aware: even though Gmail / GitHub / Linear no longer report the item, Loopr won’t auto-complete a delegated item the next time that stream runs. It will only re-enter your loop when its follow-up date arrives or when its last open delegation closes.

This means you can confidently fire d on something in your inbox: your inbox gets cleaned up, but the work stays tracked until the person you delegated it to reports back.

Managing delegations

Open someone’s detail panel to see their open delegations. Each row has:

  • The item title
  • Follow-up status — “in 3d” / “overdue 2d” / “no follow-up”
  • Inline notes (if you added any)
  • ✓ to mark done
  • ✗ to remove the delegation entirely (item stays, delegation’s gone)

Lookbacks see delegations

Delegated items don’t count as “slipped” in your lookbacks — someone else is working on them. They get their own Delegated & outstanding section that leads with anything overdue for follow-up, so your daily reflection tells you “they haven’t reported back on X” without you having to go find it.

See Lookbacks & AI Context.

Back to app