Close the loops that shouldn't be open.
Your next customers are already in your pipeline – deals that stalled, went quiet, or never quite started. The hard part isn't chasing them. It's knowing which to push, which to drop, and what the next move is. I build the system that does that reading and ranking, on repeat.
Not sure where you stand? Take the 4-minute self-check.
Getting the first conversation is no longer the hard part.
Generating leads and drafting outreach at scale used to be a bottleneck. Not anymore – anyone can spin up lists and messages now, and the tools that do it are commodities.
What's still unsolved is everything after the first interaction and beforea deal is obviously hot: the follow-through, the judgment, the “which of these 300 half-alive relationships is worth a move this week.” I call it the latent pipeline– the 80% that isn't on fire and isn't dead, while the hot 20% gets all the attention. It's where your next hot deals come from, and where almost all the winnable revenue you're leaving on the table lives.
Your CRM records this as stages. It doesn't run it. And pointing an agent at it makes things worse, not better – more noise, more confident-sounding nonsense, faster.
Two kinds of revenue teams.
The best ones treat their pipeline as a system: loops get closed, context is remembered, and the next-best action is obvious because something is actually doing the reading and ranking. When they strain, they fix the system.
Everyone else runs on gut feel and heroics, and when it strains they add headcount. It works until it doesn't – and it never compounds.
If you're reading this thinking “this is exactly our problem, and it's too complex or too far from our core for our team to build” – that is why this page exists.
Why you can't just point an agent at it.
The ideas here are simple, which is exactly why they're easy to underestimate. Three things I've learned building this for real operators:
- It's an architecture problem, not a prompt. The data doesn't fit in a context window, the relationships want a graph, and the whole thing has to run on repeat without drifting.
- Even the sharpest operators haven't built the hard part. The most capable person I've met runs deal qualification through an LLM every day – and still tells me the piece he's missing is a researcher that reads each deal and shows where the truth is diverging from the CRM.
- The AI Double Trap. Model output looks like progress even when it isn't, and once you put a model on a track it tunnels – confidently skipping the considerations that matter most. Escaping it isn't a model choice; it's frameworks, architecture, and taste applied together.
Can't I just point an agent at this?
A rough look at how much context one deal actually carries – and why "just point a model at it" is the easy part, not the answer. Move the sliders to your reality.
Emails, DMs, and internal notes across the whole relationship.
behind a single deal – and only ~49% of it is call transcripts. Most is emails, notes, and CRM records.
of moving context across your 100 deals – and it reshuffles every day as people reply, go quiet, and change their minds.
For scale: one real, data-heavy deal we measured carried ~1.8M tokens of raw context – dominated by call transcripts and system records, not emails. Most of a real deal never fits in a single prompt.
Rough assumptions: ~7,500 tokens per 30-min call, ~450 per message, plus CRM records and attachments. Conservative and illustrative, not a precise measurement.
Here's the catch: Yes, you can point an agent at one deal and say "go for it" – it'll chunk the context, summarize it, and hand you a confident next step. That part is genuinely easy now. The hard part is the other 99: ranking every deal against every other, every day, in a way you can trust. A one-shot answer reads clean while quietly dropping what mattered – and you can't see what it skipped. Getting an output is trivial. Getting one you'd stake the quarter on – each deal summarized down to what counts, the whole pipeline prioritized honestly, on repeat – is the entire job.
Summarize and prioritize – relentlessly.
Strip it all down and the whole thing is two moves: summarize a mountain of context into the few things that matter for this deal right now, and prioritize the next move across the whole pipeline, honestly. Doing those two well, at scale, on repeat, is what takes real work. Four things make it hold:
- Frameworks
- – a map of your specific revenue engine, so “what matters” is defined for you, not in the abstract.
- Architecture
- – the wiring that holds the data and the loops together at scale without drifting. It doesn't fit in a context window; some of it wants to be a graph.
- Taste
- – your judgment encoded during onboarding, plus a human deliberately kept in the loop as the final decision-maker.
- Circularity
- – run it continuously, so every closed loop feeds the next decision instead of resetting to zero. That's where the name comes from.
What it looks like when the latent pipeline is under control
You open your day to a briefing, not a dashboard – and work one prioritized action at a time. You make the calls; the machine buys you the attention to decide well.
- At riskMeridian Freight – renewal slipping
No reply in 12 days; champion opened the last email 4×. Nudge the economic buyer.
- Waiting on youNorthwind – proposal sent, no follow-through
You promised security docs on the call. Still unsent.
- Heating upHalcyon Labs – new buyer joined the thread
VP Ops looped in overnight. Good moment to multithread.
Champion is engaged but stalled on procurement. The move that changes the outcome this week: get a 20-minute intro to the VP of Finance before quarter-end.
Illustrative UI with sample data.
- Not lead generation or top-of-funnel. If that's your bottleneck, I'll point you to people who are exceptional at it.
- Not a “close faster” tool or a sales-coaching layer.
- Not a forecasting tool – a trustworthy forecast is a byproduct of getting this right, not the product.
- Not a GTM advisor, fractional exec, or time-based consulting engagement.
- Not a data vendor, an enrichment feed, or a CRM plugin you self-serve.
If your problem is the hard, unglamorous middle of the pipeline, we should talk. If it's anything on this list, I'm the wrong call.
If this is your exact problem, let's talk.
I'm having a series of these conversations to find the hardest, most interesting version of this problem worth building for. Read this far and it's yours? You'll start ahead of the line – we skip the part where I explain what I do.
How I work: success-based, priced for the size of the outcome rather than time, tied to milestones we define together, with a simple guarantee – I work the problem until it's done. It isn't an off-the-shelf module; I adapt this approach to your biggest constraint, in the way that's right for you.