Research memo · Personal intelligence layer · 2026-05-23

Personal Intelligence Primitives

The next evolution is not “more integrations.” It is a small set of intelligence primitives that every integration can emit, consult, and compose — without adding cognitive load.

Operating thesis: Every source should become evidence. Every interpretation should become one of a few typed primitives. Every mutation should be proposed unless it is raw evidence ingestion. Every proposal should carry enough context that Connor can approve, delegate, defer, or reject in seconds.

The frame

raw evidence → primitives → leverage

Connor’s insight, preserved

“Primitives for intelligence: signal radar, open tabs, memory capture, proposal recommendations.”

“These apply across integrations, and should consult each other for context, and work together to find true leverage.”

Research question

How do we make Signal Radar, Open Tabs, Memory Capture, and Proposal Recommendations into universal system primitives — while avoiding the trap of turning the personal intelligence layer into another inbox?

maximum intelligenceminimum cognitive loadcross-primitive leverage

The four current primitives

small vocabulary, large surface area
01

Signal Radar

Detects externally or internally relevant signals: changes, opportunities, risks, patterns, social/emotional cues, deadlines, market movement, technical openings.

what changed?why might it matter?
02

Open Tabs

The operational cockpit for active loops: things Connor might need to decide, do, delegate, close, research, or monitor.

what is open?what needs attention?
03

Memory Capture

Preserves raw evidence, stable facts, preferences, commitments, entity context, recurring patterns, and durable meaning.

what should be remembered?what compounds?
04

Proposal Recommendations

Turns intelligence into a typed, reviewable next move: agent action, user action, joint action, system change, outreach, research, or delegation.

what should happen?who acts?

What seems missing?

not more primitives by default

Key finding: the missing pieces are mostly control primitives, not new user-facing inboxes. They make the four primitives safe, composable, auditable, and low-noise.

Evidence

The shared substrate. Every primitive should point back to source evidence: transcript segment, email, calendar event, Telegram message, web page, file, code diff, sensor/log event.

source-backed

Entities + relationships

The graph glue. People, projects, companies, systems, workflows, and recurring pain points need stable IDs so primitives can consult each other.

who / what / where

Goals + workflows

The leverage layer. A signal matters more when attached to a goal, active project, recurring workflow, or pain pattern.

why this matters

Policy + risk

The safety boundary. Raw evidence can flow automatically; derived mutation is proposed; risky action requires explicit confirmation.

what is allowed?

Feedback + learning

The system needs to learn from approvals, rejections, ignores, edits, and successful outcomes — otherwise every integration stays noisy forever.

did this help?

Capability registry

Proposals should know what Hermes can actually do: delegate with Codex, search web, update Open Tabs, ingest to GBrain, ask Connor for API keys, publish docs.

what can be done?

Attention budget

A primitive can be correct and still not worth surfacing. The layer needs daily/weekly budgets, bundling, and quiet background compounding.

do not create another inbox

Status + verification

After proposals are applied or agent work runs, the system must prove what changed: artifact ID, URL, Open Tab ID, GBrain slug, test output, message draft.

prove done

Contradiction / drift detection

Memory and signals should notice when a belief, plan, preference, or workflow is no longer true, and propose simplification or reconciliation.

is this still true?

Cross-primitive interaction

the meta system

Sources

Telegram, Gmail, Calendar, Audio Memory, browser/SaaS, code, web, finance CSVs, WhatsApp, notes.

→

Evidence Ledger

Raw, timestamped, provenance-preserving events with privacy labels and hashes.

→

Primitive Graph

Signals, Open Tabs, Memory, Proposals linked by entity, goal, workflow, and source evidence.

Context consult

Before emitting a primitive, consult relevant memory, open loops, recent signals, and capability/policy.

→

Typed next move

Store quietly, surface in Pulse, create Open Tab, propose action, delegate work, ask Connor, or do nothing.

→

Outcome learning

Approval/rejection/application result feeds back into ranking, policy, and future thresholds.

The crucial directionality

  • Signals can create proposals when a change implies a next move.
  • Signals can create Open Tabs when a loop becomes active.
  • Signals can create memory when the signal is durable or trend-forming.
  • Memory can create proposals when consolidation reveals repeated pain, drift, or simplification opportunity.
  • Open Tabs can request signals when a stale loop needs fresh research or monitoring.
  • Proposals can become memory as decisions, outcomes, and preference evidence.

The anti-pattern to avoid

Do not make every primitive broadcast into every other primitive by default. That creates combinatorial noise.

Instead use typed conversion rules: a primitive may create another primitive only when it improves one of four outcomes: attention, memory, action, or learning.

Universal integration contract

all current and future integrations

Every integration should implement the same small contract. Not every integration needs to emit every primitive on day one, but every integration should be evaluated through this grid.

Integration surface
Signal Radar
Open Tabs
Memory Capture
Proposals
Gmail
Newsletters, stakeholder asks, receipts, churn/risk, API-key needs.
Follow-ups, deadlines, unanswered asks.
Preferences, commitments, entities, decisions.
Delegate goal, ask for keys, reply draft, research brief.
Telegram / messages
Social cues, distress, high-salience requests, project updates.
New commitments, “remind me”, unresolved asks.
Exact user phrasing, relationship context, decisions.
Send/check-in draft, create task, delegate, archive insight.
Audio Memory
Concerns, emotional tone, repeated pain, interesting ideas.
Things said aloud that imply follow-up.
Raw transcripts auto-ingest. Derived claims can be curated.
Follow-up message, research, simplify system, ask clarifying question.
Calendar
Upcoming prep needs, overloaded weeks, relationship cadence.
Meeting prep, post-meeting follow-ups.
Attendees, outcomes, recurring commitments.
Prep brief, reschedule suggestion, agenda draft.
GBrain
Anomalies, contradictions, salience spikes, trends.
Emergent loops from memory drift or repeated facts.
Durable meaning, entities, timelines, facts.
Simplify, research, reconcile contradiction, build missing integration.
Web / research
Market/paper/product signals relevant to goals.
Investigate or decide if signal maps to active project.
Summaries and evidence links, not raw dumps.
Publish memo, update strategy, delegate build.

Proposal recommendations as the action router

not one proposal type

Four proposal recipients

  1. Agent does: “Go away and research/build/delegate this.” Requires goal contract, acceptance criteria, proof.
  2. System changes: “Add this integration/rule/memory/policy after consulting GBrain.” Requires scope and rollback.
  3. Connor does: “Get API keys, answer a question, make a decision, send a human message.” Requires minimal ask.
  4. Joint work: “Connor provides intent/credentials; agent does implementation and verification.” Requires sequencing.

Proposal payload

  • Observed evidence: source quote + pointer.
  • Inferred primitive link: signal / memory / open tab / prior proposal.
  • Why this matters: goal, entity, workflow, or risk.
  • Proposed move: exact action class and owner.
  • Risk + reversibility: low/medium/high and required gate.
  • Done condition: what success looks like.
  • Proof: URL, file, Open Tab ID, GBrain slug, test output, message draft.

Proposal UX rule: a proposal should be answerable with one of a few verbs — approve, reject, defer, edit, delegate, ask me, or apply. If Connor has to inspect the whole system to decide, the proposal is too cognitively expensive.

Worked paths

from source to leverage

Signal → Open Tab → delegated work

A Telegram or Gmail signal suggests a feature gap. The system checks GBrain/project memory, sees it maps to an active goal, creates a proposal: “Delegate Codex with this /goal contract?” If approved, Hermes creates durable files, runs the agent, verifies tests, and stores outcome memory.

Signal → Memory → trend → proposal

Repeated workflow friction is captured as memory across audio, Gmail, and Telegram. Consolidation identifies a trend: “common pain in system complexity.” It proposes a simplification research/build slice rather than surfacing every individual complaint.

Stale Open Tab → research signal → memory

An Open Tab ages without progress. The system proposes research, uses Signal Radar to find external examples, ingests useful findings into memory, then returns a bounded proposal with novel solutions and a next slice.

Memory drift → simplification proposal

Memory shows the personal system is proving complicated. GBrain salience/contradiction/drift detection proposes: “Simplify these two layers; remove duplicate proposal path; preserve raw evidence auto-ingest.”

Audio concern → relationship follow-up

Audio Memory detects someone’s concern or distress. Raw transcript auto-ingests. A signal/memory candidate proposes a warm follow-up message, but outbound message sending remains confirmation-gated.

Proposal → Memory

Connor approves/rejects/edits a proposal. That decision becomes memory: preference evidence, a policy adjustment, and training signal for future thresholds.

Diligence: gain intelligence without adding load

the design constraints

One ledger, many views

Do not build separate ingestion worlds for Gmail, Audio, Telegram, Open Tabs, and GBrain. Normalize source events once, then interpret into primitives.

Raw evidence is automatic

Audio transcripts and other raw evidence should not need proposal packets to become searchable evidence. Gating belongs to derived mutations and actions.

Derived mutation is proposed

Open Tabs changes, compiled truth, outreach, calendar writes, publishing, and project work should have proposals, policy, and proof.

No primitive fan-out storm

Every conversion needs a reason. “Could create memory” is not enough. “Will help future decisions on active project X” is enough.

No new inbox

Most low-risk interpretations should compile into Daily Pulse, weekly digest, or memory, not produce immediate alerts.

No opaque magic

Every proposal must show evidence, reasoning, risk, required input, and proof path. Intelligence without auditability becomes anxiety.

Recommended next spec slices

small, safe, compounding

Slice 1 — Primitive event schema

Define a shared schema for evidence_event, signal, open_loop, memory_candidate, and proposal. Include source pointer, entity refs, privacy label, confidence, risk, and status.

Slice 2 — Cross-primitive rules engine

Add deterministic conversion rules before LLM creativity: signal→proposal, signal→open_tab, signal→memory, memory→proposal, open_tab→research_signal, proposal→memory.

Slice 3 — Proposal taxonomy

Implement proposal classes beyond create_open_tab: delegate_goal, ask_for_api_key, research_brief, reply_draft, simplify_system, capture_memory, monitor_signal, reconcile_memory.

Slice 4 — Feedback loop

Record approvals, edits, rejects, ignores, applications, and outcomes. Use that to reduce noise and rank future proposals by actual usefulness.

Slice 5 — Integration scorecard

For every source, show whether it supports evidence ingestion, signal extraction, Open Tab proposals, memory capture, proposal generation, policy gates, and verified apply.

Slice 6 — Personal intelligence Pulse

Bundle primitive activity into a low-load surface: what changed, what matters, what is waiting on Connor, what the agent can do, and what quietly compounded.

Suggested immediate implementation target: write the primitive schema and integration scorecard first. They create the shared language that lets Gmail, Telegram, Audio Memory, GBrain, Open Tabs, and future connectors all converge without bespoke logic multiplying in every direction.

Bottom line

The personal intelligence layer should not become a pile of clever automations. It should become a primitive graph: source-backed evidence, typed signals, active open loops, durable memory, and proposals that convert context into leverage.

The design win is that every integration gets smarter by plugging into the same primitives, while Connor experiences fewer surfaces: mostly Daily Pulse, Open Tabs, and high-quality proposal approvals.