Find contacts for signal accounts

The prompt

The real prompt behind the steps above — detailed enough that an agent with a people-search tool, email/phone enrichment, and CRM access can run it as written.

# Find contacts for accounts with no one on file

You have access to your CRM, a people-search tool, and an outreach
campaign tool. Run this against **[the segment of accounts worth
checking — e.g. anyone who left a review, replied to a form, or showed
any other signal of interest]**.

## 0. Set up (skip if you're already connected)

If you don't already have live tool access for this, connect it first
— this prompt is only as real as the tools behind it:

1. Create a free account at app.tulina.ai.
2. Add Tulina's MCP server to your assistant: https://mcp.tulina.ai/mcp
3. In Tulina, connect your own API keys for the tools this prompt uses
   — your CRM, people search, and your outreach tool.

Once connected, your assistant has real tool access and the rest of
this prompt runs as written.

## 0b. Already on Tulina? Three things around the run

An account and the MCP server are not the whole setup. Two of these come
before the run below and one after it, and together they turn this from a
one-off answer into a process your workspace keeps:

1. **Activate this process's connectors first.** Call
   `oto_connector(op="list")`, match it against the tools named in step 3
   above, and `oto_connector(op="select", name="...")` every one that
   isn't active yet. Selecting a connector does not mount its tools in the
   conversation you're already in — reach them through `oto_call` for this
   run, or open a fresh conversation once they're all on.
2. **Attach the work to an existing project.** `oto_project(op="list")`
   shows your active org's projects: pick the one this work belongs to
   rather than opening another, and keep its id. The project is where this
   process, the tables it writes to and the connectors it uses hang
   together.
3. **When the run is done, save it as a process — with its graph.** Write
   the body with `oto_procedure(op="set", ...)`, then attach it with
   `oto_project(op="link", project_id=..., target_type="procedure",
   target_ref="<your slug>")`. The body has to carry a drawing: read
   `oto_guide(op="read", slug="procedure-flowchart")` and follow it
   exactly — ONE untagged fenced block in that grammar, opening with the
   trigger and a quoted example of what you'd type to start a run. Tulina
   parses that drawing back into the graph it renders as the process's
   default view, which is what makes it come out in the same style as
   every other process in the app; a drawing the grammar can't read falls
   back to raw characters instead. Saving a process needs org-admin
   rights — without them, hand the finished body to someone who has them.

## 1. Find accounts with a signal but no owner

- Filter your CRM to the segment that already showed interest — a
  review, an inbound reply, any recorded signal — and keep only the
  ones with nobody linked as a contact yet.
- Combine the signal filter and the no-contact filter in one query
  rather than fetching everything and checking client-side; this is a
  list you'll re-run on a schedule, so keep it cheap.
- This is the whole point of the run: these are accounts that already
  raised a hand, and nobody followed up because nobody was ever found.

## 2. Search for the right people

- Define the two or three roles actually worth reaching for your
  product — commonly the founder/CEO and whoever owns the function your
  product touches (e.g. marketing, ops, procurement).
- For each account, search by company domain filtered to each role. An
  account with no match for a given role isn't an error — log it as
  "not found" and move on; it doesn't block the roles that did resolve.

## 3. Keep only the most senior match per role

Where a search returns several plausible people for the same role,
don't take the first result — judge on title match and seniority. A
"Head of Marketing" search that returns a marketing coordinator and a
CMO should keep the CMO.

## 4. Check for existing records before creating anything

- Match every kept candidate against your CRM by email.
- A match means the person already exists — update their record instead
  of creating a duplicate. No match means create a new one.

## 5. Push the contacts back to your CRM

- Create or update each contact, linked to the account it came from,
  and tagged with the same segment the account was pulled from — so
  the roster stays traceable to why it exists, not just a loose list of
  names.
- Batch the writes where your CRM supports it, rather than one call per
  contact.

## 6. Add them to the outreach campaign

- Add every resolved contact — new or updated — to your outreach
  sequence, carrying at least name, email, company, and role.
- Never add the same contact to the same campaign twice; check before
  adding, not after.

## Output

Report: how many accounts matched the segment, how many contacts found
per role, how many were new vs. already on file, how many pushed to the
CRM, how many added to outreach, and which accounts came up empty for a
given role.