Who's Missing From Your Circle? Private Network Analysis with a Local AI

Open your phone's contacts and think about what you can't write there. "Every conversation with this one leaves me drained." "All take, no give, three favors never returned." "Brilliant engineer, would be perfect for the Q4 project — if I ever followed up." "Ghosted me, but their newsletter is still the best in the field."

You can't write those notes into LinkedIn, a cloud CRM, or a hosted assistant — not because the software lacks a field, but because the honesty is the data. Your relationship graph, described truthfully, is the most intimate dataset you own: who energizes you, who owes you, who you owe, who you're quietly avoiding. Paste that into a cloud chat and the analysis might be great — and the notes now live on someone else's servers, tied to real people's names.

This is the rare workflow where local-first isn't a nice-to-have; it's the enabling technology. Run the analysis on your own machine with Ollama, and suddenly honest notes are safe to keep. And once the data is honest, the analysis gets useful: who's missing from your circle, which relationships are dormant, and who pairs with whom for mutual growth — answers a sanitized cloud version can never produce.

The File You Couldn't Keep Anywhere Else

Start with the dataset. One JSON file per person, or one file for everyone — structure matters more than format:

{
  "people": [
    {
      "name": "N.",
      "provides": ["fintech ops experience", "candid product feedback"],
      "needs": ["automation help", "content editing"],
      "energy": "energizing",
      "reciprocity": "mutual",
      "last_contact": "2026-06-14",
      "notes": "prefers voice notes; hates hype language; follow up re: Q4 project"
    },
    {
      "name": "K.",
      "provides": ["design skills"],
      "needs": [],
      "energy": "draining",
      "reciprocity": "one-sided-toward-me",
      "last_contact": "2026-02-02",
      "notes": "three unreturned favors; keep professional distance"
    }
  ],
  "goals": [
    "ship client-ops machine by December",
    "grow YouTube to consistent weekly output",
    "close 3 more retainer clients"
  ]
}

Notice what this file contains: judgments. Energy levels, reciprocity verdicts, private assessments of real, named people. That is exactly why it lives on your disk and nowhere else — and exactly why it's worth more than any sanitized export.

The Circle Audit, Run by a Local Model

Feed the whole file to Ollama in one pass and ask for structure back:

ollama run qwen2.5:7b """
Here is my relationship file: {{people.json}}

Act as an analyst. Return JSON with:
1. clusters: group people by what they provide (max 6 groups)
2. dormant: anyone with last_contact > 90 days ago
3. one_sided: reciprocity flags, both directions
4. mutual_pairs: people whose provides/needs complement each other
5. honest_observations: 3 non-flattering patterns you notice
Be blunt. I am the only reader.
"""

That last line — I am the only reader — is the whole trick. A model reading honest inputs privately can say "your 'advisors' cluster is really a fan club; nobody in it challenges you," which is the observation that changes something. The same prompt in a cloud chat, over data you self-censored first, produces polite mush.

The Goal-to-Gap Match

The strategy pieces are written elsewhere — audit your circle, keep a catalyst per goal. The machine version takes your three to five goals and finds who's missing:

Goals: {{goals}}
Known: {{what each person provides}}

For each goal, return:
- who I already know who accelerates it (name + why)
- what skill/access the goal needs that NO ONE in my file provides
- one dormant contact whose reactivation would serve this goal

The output is your recruitment map: two goals covered by current contacts, one goal with a hole where a person should be. Now "networking" has a target — you're looking for a specific missing piece, not collecting business cards.

The Signal Flare, Assisted Locally

The strategy guides also say: publish honest work so the right people arrive warm. The local machine helps on both sides of that flare. On the receiving side, feed it the RSS feeds or newsletters of your top ten catalyst targets and ask for a weekly digest of what they're actually thinking about — so when you do comment or write, you're responding to their current ideas, not their brand. On the sending side, your own drafts can pass a private test before publishing:

Draft: {{my draft post}}
Catalyst list values: {{what the people I want to meet care about}}

Questions: Does this say anything only I would say?
Does it engage what this specific audience is currently discussing?
Rate 1-5 and name the weakest paragraph.

No ghost-writing, no engagement farming — just a private editor that checks whether your signal flare is actually signaling you, loudly enough, in the direction of the people you're hoping to attract. The magnet gets stronger exactly when it gets more honest, and a local model applying your own stated values is the cheapest honest editor available.

What the Audit Usually Finds

The Nudge Machine (With the Brake On)

Here is the boundary that keeps this whole system decent: the machine analyzes and reminds; it never pretends to be you. An n8n workflow can watch for dormancy and draft an opener — but a human sends it, meaning it:

workflow: circle-keeper
schedule: "0 8 * * 1"
nodes:
  - name: scan
    type: code
    rule: "flag anyone dormant > 90 days with energy != draining"
  - name: draft-opener
    type: http-request
    url: "http://localhost:11434/api/generate"
    body:
      model: "llama3.2"
      prompt: "Draft a 2-sentence, warm, zero-ask re-opener to {{name}} referencing {{notes}}. No favors, no pitches."
  - name: queue-for-review
    type: telegram
    message: "Dormant: {{name}} ({{days}}d)\nDraft: {{draft}}\nSend/edit/skip?"
  - name: log-decision
    type: write-file
    destination: "/peak/network/{{name}}-outreach.md"

Notice what is absent: auto-send. The draft arrives on your phone Monday morning; you edit it into your own voice or skip it. The system's job is memory and initiative, not impersonation. A relationship message a machine sent on your behalf is a betrayal with a delivery receipt — the review step is the ethics, implemented as a queue.

The same discipline applies to engagement: when someone on your catalyst list publishes something good, a local reader can summarize it and suggest a comment angle — but the comment you post should be one you'd type. Assist the sincerity; never fabricate it.

Why This Beats a Cloud CRM for Actual Humans

Make It Practical This Week

• Write honest entries for your ten most-load-bearing relationships tonight — energy and reciprocity fields do the work.
• Run the audit prompt once. Read honest_observations twice; that's the section that earns the setup.
• Pick one dormant, non-draining contact and send one zero-ask message this week — human-written, machine-remembered.
• Add your three goals to the file before the next run; the gap map is the output that changes who you look for.

Relationships stay human because a human decides, writes, and means each message. The local machine's contribution is quieter: it remembers everyone, notices the drift, sees the holes — and keeps every blunt, private, uncharitable note exactly where it belongs. On your machine, next to the rest of your honest work.

Frequently Asked Questions

Isn't analyzing relationships this way manipulative? The analysis is private and the actions stay human-reviewed — that's a different thing from automation that impersonates you. Knowing who's dormant or one-sided is just paying attention at scale; the ethics live in what you send, and nothing here sends without your edit. If a nudge machine helps you reappear warmly in someone's life instead of vanishing, that's the opposite of manipulation.

Why not just use the notes field in my existing CRM? Because you won't write the truth into it. Every cloud field carries a mental "who else can read this" tax, so the notes get diplomatic — and diplomatic input produces useless analysis. The local file earns honesty by construction, and honest notes are the entire fuel of the audit.

What about keeping the data current? Pair the file with a five-minute Friday habit: update last_contact for anyone you touched, add one note. The n8n scan handles staleness detection; your only job is the occasional true sentence. Dated entries also make the audit diffable — run it monthly and see relationships cool or warm over time.

Could this run with a small model, or do I need a big one? The audit over 30–50 structured entries runs fine on a 7B-class model — it's clustering and flagging, not poetry. Bump to a larger model only for the honest_observations section if the small one stays too polite; blunt pattern-calling is the one capability worth spending parameters on here.