Signals in.
Revenue out.
I build the machine.

1. signal + logic. waterfall enrichment. finds companies, verifies fit, enriches contact and tech stack.
2. relationship intelligence. maps existing relationships for first degree warm paths.
3. sending infrastructure. secondary domains on isolated IPs. nothing touches the primary domain.
4. execution. sequences run only once a prospect clears the waterfall.
5. system of record. positive replies only. raw scraped data never lands.
6. orchestration. an agent connected over MCP to layers 01 and 02. reads the signal sources, reasons about fit, decides what needs a human.

1. tech stack verification. confirm the account’s stack matches the thesis.
2. hiring intent. parse job descriptions for the specific language that predicts a buyer.
3. persona discovery. pull the actual buyer, only after g1 and g2 clear.
4. contact verification. nothing moves downstream on a guess.

• warm path found: alert the specific teammate to send a personal note. automation never touches that relationship.
• high fit, no warm path: automated sequence across email and social on a set cadence.
• every cold list: executive review before it ships. nothing sends unchecked.

• suppression: domain and profile enriched lists across every closed and active account. zero outbound to anyone we already knew.
• hygiene: deduped migration debris. quarantined bad partner records into an isolated stage so the forecast stayed honest.
• deliverability: dedicated secondary domains and a multi week warm up before real volume. account specific variables so no two emails match structurally.
• honest gap: no automated retry or alerting. it never ran unattended, so it never bit. first thing I’d add.

1. source. public signals define the candidate set. no bought lists.
2. qualify. free and cheap checks first. the expensive step waits.
3. enrich. only the survivors. every credit has a reason.
4. send. from isolated infrastructure, warmed, rotated, monitored.
5. record. a reply creates the record. a send does not.

• technographics: what the account actually runs, verified, not inferred from a logo wall.
• hiring language: job descriptions parsed for the specific phrases that predict a buyer, with the quote kept as evidence.
• public conversation: people describing their own stack and pain in the open.

• non negotiables are gates, not weights. fail one and the score is irrelevant.
• thin evidence reads as insufficient data, never as a low number.
• the threshold is the budget. below it, nothing is enriched and nothing sends.

• every meeting carries its originating signal source as a property.
• cost per qualified meeting rolls up by source, so spend follows what converts.
• signals that never book get their budget cut automatically.

• system of record: one company per target, one deal per role, an eleven stage pipeline from sourced to hired.
• stage watcher: a daily automation diffs each deal against its last known stage and writes the real next action into my task manager. only on change, never on noise.
• scheduled agents: eight of them, 45 runs a week. verify roles are live, rescore on new evidence, flag stale deals, catch inbound replies.
• enrichment: same waterfall shape as module_01, pointed at hiring managers instead of buyers.

• search before create: every new company is checked against existing records first. an audit caught five duplicate pairs and pointed each one at its primary record before merge.
• required evidence: no score without the posting URL on the deal, because the liveness checks depend on it.
• defined stages: every stage has a written meaning, so a stage change means the same thing every time it happens.
• closed means closed: a lost deal pulls the account out of every outreach queue unless it clears a scored exception.

The stage watcher was quietly creating duplicate tasks. The dedupe logic read fine: look up the deal’s last stage, only fire on change. The key was sometimes stored as a number and sometimes as a string, so a lookup would miss its own record, read back empty, and fire again.

Found it by pulling raw records instead of trusting the workflow’s own view. Forced the key to one type at the boundary, backfilled existing records so the fix wouldn’t flood the next run. Reading what the machine actually did, not what it was supposed to do, is most of this work.