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, your private notes about them, 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.
Add to and tick off the shared agenda.
Edit a shared notes doc with you in real time — see below.
Keep their own private notes that you can’t see.

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.

A summary header at the top of the portal shows the count of open asks and open agenda items as anchor pills, so the delegatee can jump straight to whatever has work in it. On wide screens the notes column sticks to the left while asks and agenda scroll independently on the right; on narrow screens everything stacks.

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). Anything you write in the Shared notes doc is also visible to them — that’s the point of it. Your private “My notes” field on the People page is not exposed.

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.

Three notes fields — mine, ours, theirs

Each person has three separate notes surfaces, deliberately distinct so nobody accidentally writes the wrong thing in the wrong place:

My notes — plain markdown on the People page. Only you ever see these. Use them for context, dev goals, things you want to remember before your next sync.
Shared notes — a rich-text doc at the top of the public portal, visible and editable by both of you, like a shared Google Doc. Auto-saves as you type. Both sides see each other’s edits and cursors live (see below). Use this for anything you’d otherwise paste into a DM and re-paste later: meeting notes, links you both want, decisions.
Their notes — a private notes doc at the bottom of the portal, visible only to the delegatee. You can’t read it, even from your own account; it’s enforced at the database layer. Use it as the place you tell them: “feel free to think out loud here, this isn’t a performance review.”

Live collaboration on shared notes

Shared notes use a real-time collaborative editor. When both of you have the portal open at the same time:

A small pill in the header shows who else is currently viewing the page — your name in blue (page owner) or theirs in green (token-holder).
Each side’s caret and selection appear in the editor in their colour, with a name flag — so you can literally see them typing alongside you.
Edits stream as they happen, not on save, so the page never feels like it’s catching up. The doc auto-persists in the background; if you close the tab everything you typed is already saved.

There is no version history or branching — it’s one shared document with last-write-wins semantics. Treat it like a whiteboard, not a wiki.

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.

Either side can mark an item done with the ✓ button (it does not delete — completed items move to the Recently finished strip on the portal alongside completed asks, so you can both see the trailing few weeks of progress in one place). 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.

Linking — when both of you are on Loopr

If the person you’re tracking is also a Loopr user, you can link their portal page to their account. The two records — yours of them, and theirs of you — become a single shared 1:1 page; new asks and agenda items skip email entirely and land directly in the other person’s loop.

How linking happens

The link is initiated from the portal, not from the People page:

Share the /d/<share_token> link as you normally would.
The other person opens it while logged into their own Loopr account.
They see a “Link this page to my Loopr account” banner above the asks section. Clicking it links the page in one step.

After linking:

You appear on their team list, and they appear on yours. Loopr finds-or-creates a counterpart Person record on their side (matching your email if they already had a row for you), so neither of you has to manually re-add the other.
The shared page becomes private. The /d/<token> URL stops serving the page to logged-out visitors and to anyone who isn’t one of the two linked accounts. The page header shows “Your name & their name” — viewer first — so it’s obvious whose seat you’re sitting in.
Both sides can ask, both sides can write to the agenda. A “Send an ask to <them>” form appears in the asks section with title, notes, and an urgency selector. Whatever you send lands as a Loop item in their loop with source: :delegation_update — and vice versa.
Email is skipped. While linked, new delegations and agenda items to that person no longer trigger an email — they go straight to the other person’s loop. (Their agenda_notify_urgency_threshold controls whether the new item also fires a push notification, exactly like the existing portal-add agenda flow.)
Linked people can’t be deleted from the team list. The delete button is replaced with Unlink. Unlinking is also bidirectional — one click clears the link on both sides — and the underlying Person rows stay (they aren’t deleted).

Private notes — both sides get one

Pre-linking, Their notes is the delegatee’s-only scratchpad. Once linked, both sides get their own private notes block on the shared page: yours lives on the counterpart record on their team, theirs on the original record on yours. Neither side can read the other’s.

Shared notes survive the merge

When linking, if the other person’s record on their side already had shared notes (for example, they were treating you as a delegatee on their team before you both linked), Loopr appends those notes into the canonical shared doc with a small “Merged from previous notes” separator. Neither side loses what they already wrote.

Completing asks closes them on both sides

When you complete a :delegation_update notification in your loop, Loopr follows the back-pointer to the originating delegation on the asker’s side and marks it done. If their original ask had other delegates still open, they’ll get a normal “Update from <you>” item in their loop with any result note. If yours was the last one, the original ask resurfaces in their loop on its own.

Locked-link sign-in flow

If someone hits a linked URL without being signed in, Loopr shows a “Sign in to view this page” message with a link to the sign-in form (instead of a generic 404). Logged-in users who don’t match either side of the link still get a flat “Link not found” — Loopr doesn’t leak which accounts a private page is shared with.

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.