Stop asking "who should I pitch?" Ask "what's the next move?"

The list-building trap

List-building is the most seductive procrastination in fundraising because it is indistinguishable from work. You're in the spreadsheet. You're researching funds. You're adding rows. Every hour produces a visible artifact that's longer than the hour before. But a longer list is not a more advanced round. A list optimizes for coverage (how many investors do I know about) when a round is won on sequencing (what is the right next action, on the right thread, right now).

The deeper problem is that the investor record is the wrong atomic unit. When the row is the unit, your brain treats every investor as a single binary task: pitched / not pitched. So the list becomes a giant to-do where each item is "convert this human into a yes," which is too big to start and never feels done. You can't act on "Sarah at Foundry." You can only act on a move: send Sarah the intro ask you drafted, answer the objection she raised on Thursday, send her the metric she asked for, or decide she's dormant and put her on a 30-day timer.

Same record. Wildly different moves depending on where the thread sits. The record is static. The move is alive. When you organize fundraising around records, you get a list. When you organize around moves, you get a queue you can run.

The fix: the next move is the unit

Here is the shift in one line. Stop maintaining a list of investors. Start maintaining a queue of moves.

A move has three properties a record doesn't:

1. It's atomic. You can do it in one sitting and know when it's done. "Send Sarah the cohort retention chart" is a move. "Convert Sarah" is not.
2. It's context-dependent. The right move depends entirely on the state of the thread, not on who the investor is. The same partner is a different task on Monday than on Friday.
3. It decays. Most moves have a clock. A warm intro acted on today is worth more than the same intro acted on next week. A move you can name but don't make loses value while it sits.

When you internalize this, "who should I pitch?" dissolves into a better question you can answer in five seconds per row: given where this thread is, what is the one next move that advances it? That question has an answer for every investor, including the ones you'd otherwise skip.

The 12 next-move types

There are not eighty different things to do in a round. There are about twelve, and every investor on your list maps to exactly one of them at any given moment. Naming them turns a vague list into a sortable queue.

Every investor in your spreadsheet is, right now, one of these twelve. Not "a person to pitch." A specific move with a specific trigger. The work of fundraising is keeping each thread pointed at its correct next move and clearing the highest-decay ones first.

The same investor, five different moves

The point that breaks the list-building habit: the right move is a function of thread state, not investor identity. Take one investor, Sarah at Foundry, and watch the correct next move change completely based on context.

SAME INVESTOR — SARAH @ FOUNDRY — FIVE THREAD STATES

COLD     no relationship, never contacted
         -> Move #1: source a warm path
            (who in my network knows Sarah? request the intro)

WARM     intro was made 1 day ago, she replied "happy to chat"
         -> Move #3: act on the fresh intro
            (book the call NOW, before the warmth decays)

ACTIVE   had the call Tuesday, she asked about month-3 retention
         -> Move #5: answer the open objection
            (send the retention cut + narrative, this week)

PASSED   passed last month, liked the team, wrong stage for them
         -> Move #11: request a referral
            ("who else should we be talking to at our stage?")

DORMANT  talked 4 months ago pre-launch, went quiet, never a no
         -> Move #8: send a milestone update
            (we launched + hit X; reopen with a concrete reason)

Five states, five moves, one investor. If your list has a single "next step" column and you fill it in once, it's wrong within a week, because the thread moved and the column didn't. The move is the thing that has to stay current, not the record.

This is also why "who should I pitch?" is the wrong daily question. It assumes the work is selecting people. The work is maintaining the correct move on each live thread and executing the most time-sensitive ones first.

The next-move decision tree

When you look at any investor and don't know what to do, run this. It resolves to one of the twelve moves in a handful of questions, and it forces the high-decay moves to the front.

NEXT-MOVE DECISION TREE  (run per investor, top to bottom, stop at first yes)

START: Is there an OPEN ASK from them I haven't fulfilled?
  (diligence doc, reference, data, a question they asked)
  YES -> Move #6: deliver the diligence ask        [HIGHEST PRIORITY]
  NO  v

Is there an UNANSWERED OBJECTION from our last contact?
  YES -> Move #5: answer the open objection
  NO  v

Did a WARM INTRO to them land in the last 48h?
  YES -> Move #3: act on the fresh intro
  NO  v

Did we have a CALL in the last 72h with no follow-up sent?
  YES -> Move #4: send the meeting follow-up
  NO  v

Is there a LIVE thread that went quiet 7+ days ago?
  YES -> Has the thread been circling with no decision?
         YES -> Move #10: ask for the decision
         NO  -> Move #7: re-engage the stalled thread
  NO  v

Have they PASSED but cleanly / warmly?
  YES -> Move #11: request a referral
  NO  v

Did we speak before but it went DORMANT (no live thread, no no)?
  YES -> Do I have a NEW milestone since we spoke?
         YES -> Move #8: send a milestone update
         NO  -> Move #9: park on a timer (set re-touch date)
  NO  v

Have we NEVER made contact?
  -> Do I have a warm path?
     YES -> Move #2: send the first touch (intro-enabled)
     NO  -> Move #1: source a warm path

ALREADY IN? -> Move #12: close and confirm

The order is the product. Open asks and unanswered objections sit at the top because they're the highest-intent, highest-decay moves in a raise: someone is waiting on you, and every day you don't respond is a signal about whether you can execute. Cold-list moves (source a path, first touch) sit at the bottom because they're infinite supply and zero decay. The list never stops you from adding more cold rows. The tree stops you from doing cold-list busywork while a live thread rots.

Before / after: Monday morning, two ways

THE LIST (what most founders open Monday)
- 80 rows, "next step" column blank or says "follow up"
- you scroll, feel the weight, pick the least scary name
- send one generic note to a cold investor (zero decay, easy, useless)
- the open diligence ask from Thursday: still sitting
- the objection from last week's call: still unanswered
- net round movement: ~0, but the list "felt managed"

THE QUEUE (what the move-as-unit gives you)
- run the tree across live threads, not the whole list
- top of queue: deliver the data Sarah asked for Thursday (open ask)
- next: answer the retention objection from the Tuesday call
- next: act on yesterday's intro before it cools
- cold first-touches: batched for later, they're not decaying
- net round movement: three live threads advanced before lunch

The list and the queue contain the same investors. The difference is that the queue is ordered by what advances the round, and the list is ordered by what's least uncomfortable. One is a plan. The other is a place to hide.

Where RoundOS fits

You can run this by hand, and you should start there. Take your existing list, add a single column called "next move," and fill it from the twelve types using the decision tree. That alone will change what you do Monday morning.

Where the manual version breaks is keeping the move current. The right move depends on thread state, and thread state lives scattered across your email, your calendar, your meeting notes, and a spreadsheet that's accurate the day you update it and stale by the end of the week. To set the correct next move on forty threads by hand, you have to reconstruct, per investor, what was last said, what they asked for, what you owe, and how long it's been sitting. That reconstruction is the actual work, and it's why the "next move" column goes blank again three days after you fill it.

RoundOS reads thread state from the sources where the round already lives, your email, calendar, meeting notes, LinkedIn exports, and investor spreadsheet, and sets the next move on each investor from that context: it sees the diligence ask that's open, the objection from a call transcript that was never answered, the intro that just landed, the thread that's been quiet nine days. It maps each one to its move type and ranks them by decay, so what you open is not a list of eighty names but a queue of moves, highest-leverage first, each tied to the specific context that triggered it. The job is not "AI for fundraising." It's one thing: turn a static list of investor records into a live, ordered queue of next moves, so you never again open your raise to eighty rows and the same blank next step.

Do this today

Open your investor list and add one column: "next move." Pick your ten most important live threads and, for each, run the decision tree and write the single move from the twelve types. You'll find at least one open ask or unanswered objection you'd let slip, and acting on that one item is a better Monday than adding ten more cold rows. Then make the rule real: you don't get to add new names to the list until every live thread has a current, correct next move.

When you want that next-move column set and re-ranked for you from the context you already have, connect the sources that hold your round and let RoundOS generate the day's move queue.

Next-move system

THE 12 NEXT-MOVE TYPES
 1. Source a warm path      — want them, no relationship yet
 2. Send the first touch    — path exists / going direct, nothing sent
 3. Act on a fresh intro    — intro landed <48h ago, warmth is live
 4. Send meeting follow-up  — call <72h ago, momentum decaying
 5. Answer the objection    — concern raised, left hanging
 6. Deliver the diligence ask — they asked for data/ref/doc, it's open
 7. Re-engage stalled thread  — live convo quiet 7+ days
 8. Send a milestone update   — give a passed/dormant investor a reason to reopen
 9. Park on a timer           — wrong now, set a re-touch date
10. Ask for the decision      — circling thread, force yes/no/by-when
11. Request a referral        — passed cleanly, mine their network
12. Close and confirm         — they're in, lock terms + wire

DECISION TREE (run per investor, stop at first YES)
  Open ask from them unfulfilled?      -> #6  [top priority]
  Unanswered objection?                -> #5
  Warm intro landed <48h?              -> #3
  Call <72h ago, no follow-up?         -> #4
  Live thread quiet 7+ days?
     circling, no decision -> #10  | else -> #7
  Passed cleanly / warmly?             -> #11
  Dormant, no live thread, never a no?
     new milestone -> #8  | else -> #9 (timer)
  Never contacted?
     warm path -> #2  | no path -> #1
  Already in?                          -> #12

PRIORITY ORDER (clear top-down)
  Open asks + objections  (someone is waiting on you, high decay)
  Fresh intros + meeting follow-ups (time-sensitive warmth)
  Stalled-thread nudges + decision asks
  Milestone reopens + referrals
  Cold first-touches + path-sourcing (infinite supply, zero decay — last)

THE RULE: no new names on the list until every live thread
          has a current, correct next move.