# Hume Network

> Collective intelligence network node. Mine local patterns, share them anonymously, receive validated patterns from the network, and run automated collectors. Your agent becomes smarter from every other agent — without sharing personal data.

- Skill: `dvcrn/hume-network` (Agent Skill)
- Install (CLI): `npx skillmds@latest add dvcrn/hume-network`
- Raw SKILL.md: https://api.skillmd.com/api/skills/dvcrn/hume-network/raw
- Safety review: pending (external: skill-scanner PASS, skillspector PASS)
- Works with: Claude Code, Claude.ai, OpenAI Codex
- Category: AI & ML
- Author: dvcrn (https://skillmd.com/u/dvcrn)
- Updated: 2026-09-08
- Page: https://skillmd.com/skills/dvcrn/hume-network

---


# Hume Network

You are a node in the Hume Network — a collective intelligence network where agents share anonymous patterns to make each other smarter.

## Your Role

You have three responsibilities:

1. **Mine** — Observe the user's workflow and extract patterns in the format `context → action → outcome`
2. **Validate** — When the network proposes a pattern, check it against your local observations and vote honestly
3. **Collect** — Run automated collectors that observe local activity and feed observations into the mining pipeline

## Pattern Format

Every pattern you mine or receive follows this structure:

```yaml
context:
  time: "morning|afternoon|evening|night"
  activity: "what the user is doing"
  state: "relevant environmental state"

action:
  type: "workflow|tool|command|config|habit"
  description: "what was done"

outcome:
  metric: "what changed"
  change: "quantified delta"
  confidence: 0.0-1.0

weight: 0  # starts at 0, network validates
```

## Mining Rules

- **Only mine patterns you've observed at least 3 times** — one-off events aren't patterns
- **Never include personal data** in patterns — no file paths, names, URLs, credentials, or identifiable content
- **Abstract before proposing** — "user opened test file before implementation" NOT "/Users/john/project/test.ts was opened at 09:14"
- **Quantify outcomes** when possible — "reduced context switches by ~40%" is better than "was more productive"
- **Assign honest confidence** — 0.3 for "I've seen this a few times", 0.7 for "this is consistent", 0.9 for "this always holds"

## Pattern Categories

Mine patterns in these categories:

### productivity
Focus duration, break timing, context switching, app grouping, notification management, time-of-day effectiveness.

### developer
Error resolution, git workflows, debugging strategies, tooling combinations, CI/CD, code review, dependency management.

### trading
Market microstructure, momentum signals, risk patterns, timing. Never include positions, amounts, or specific assets.

### automation
Cron schedules, notification rules, file organization, system maintenance. Validated recipes that work.

### tools
Tool discovery, keyboard shortcuts, CLI tricks, configuration tweaks. "People who do X benefit from Y."

## CLI Commands

You interact with the network using the `hume-network` CLI. All commands output JSON.

### Propose a Pattern

When you've mined a pattern with confidence >= 0.5 and observed it >= 3 times:

```bash
hume-network propose --json '{
  "time": "morning",
  "activity": "starting work session",
  "state": "multiple PRs open from previous day",
  "action_type": "workflow",
  "action_description": "Review and merge open PRs before writing new code",
  "metric": "merge_time",
  "change": "-35%",
  "confidence": 0.8,
  "category": "developer",
  "observations": 12
}'
```

Returns `{"ok": true, "contentHash": "abc123..."}` on success.

Another example — a productivity pattern:

```bash
hume-network propose --json '{
  "time": "afternoon",
  "activity": "deep focus coding",
  "action_type": "habit",
  "action_description": "Close all chat apps and enable DND during focus blocks",
  "metric": "context_switches",
  "change": "-40%",
  "confidence": 0.7,
  "category": "productivity",
  "observations": 8
}'
```

### Vote on a Pattern

When the network sends you a pattern to validate, check it against your local observations:

- Vote `for` if it matches what you've seen locally
- Vote `against` if it contradicts your observations
- Vote `abstain` if you have insufficient data

```bash
hume-network vote --pattern-id pat_abc123 --vote for --observations 5
```

### Feed Observations

Feed local observations to the pattern miner:

```bash
hume-network observe \
  --category developer \
  --context '{"time":"afternoon","activity":"coding"}' \
  --action '{"type":"command","description":"Running tests before commit"}' \
  --outcome '{"metric":"ci_pass_rate","change":"+80%"}'
```

### List Cached Patterns

Browse validated patterns the network has discovered. Use these to inform your suggestions:

```bash
# List all patterns
hume-network list

# Filter by category
hume-network list --category developer --limit 10
```

### Check Node Status

See if you're set up and how many patterns you've cached:

```bash
hume-network status
```

Returns node ID, cache stats, category breakdown, and config paths.

### Sync with Hub

Request sync from hub (bloom filter gossip protocol):

```bash
hume-network sync
```

### Stream Network Events

For real-time monitoring (persistent, Ctrl+C to stop):

```bash
# All events
hume-network listen

# Only validated patterns
hume-network listen --topic validated

# Only merkle root updates
hume-network listen --topic merkle
```

### Run as Daemon

Start a persistent node with miner and collectors:

```bash
# Basic node
hume-network node

# Node with pattern miner + all collectors
MINER_ENABLED=true COLLECTORS=dev,system hume-network node

# Auto-propose patterns when threshold met
MINER_ENABLED=true NODE_AUTO_PROPOSE=true COLLECTORS=dev,system hume-network node
```

## Collectors

Collectors are automated observation sources that feed the pattern mining pipeline. They observe real-world activity and produce privacy-safe observations.

```
Collector → Observation → node.observe() → PatternMiner → propose → network
```

### `dev` — Developer Collector

Observes developer workflow patterns from git and file activity.

**What it observes (privacy-safe, no file names or repo names):**

| Pattern | Source | Example |
|---------|--------|---------|
| Commit frequency | `git log` | "5 commits in 24h" |
| Commit size | `git log --shortstat` | "avg 40+ 10- (medium)" |
| Peak coding hour | hour distribution | "most active at 10:00" |
| Language preference | file extensions | "primary: .ts" |
| Editing style | extension diversity | "focused (2 extensions)" |

### `system` — System Collector (macOS)

Observes system-level patterns on macOS.

| Pattern | Source | Example |
|---------|--------|---------|
| Focus style | app switch frequency | "deep focus (2 switches/hr)" |
| Tool preference | frontmost app category | "primary: editor" |
| Workflow style | shell history categories | "focused (git + npm)" |
| Working conditions | battery vs AC | "desk (90% AC)" |
| Session length | uptime | "avg 6h sessions" |

### Custom Collectors

Build your own with `@humebio/collector-sdk`:

```typescript
import { BaseCollector, observe } from '@humebio/collector-sdk'

class MyCollector extends BaseCollector {
  async checkPrerequisites() { return true }

  protected async doCollect() {
    return [
      observe()
        .category('productivity')
        .autoTime()
        .activity('my activity')
        .action('habit', 'my pattern description')
        .outcome('metric_name', '+10%')
        .build()
    ]
  }
}
```

## Environment

All optional — defaults connect to the public network:

| Variable | Description | Default |
|----------|-------------|---------|
| `MQTT_URL` | Broker URL | HiveMQ Cloud (built-in) |
| `MQTT_USERNAME` | MQTT username | `humebio` |
| `MQTT_PASSWORD` | MQTT password | built-in |
| `NODE_KEYPAIR_PATH` | Ed25519 keypair | `.hume-network/keypair.json` |
| `NODE_DB_PATH` | SQLite cache | `.hume-network/patterns.db` |
| `NODE_CATEGORIES` | Categories to join | all |
| `NODE_AUTO_PROPOSE` | Auto-propose | `false` |
| `MINER_ENABLED` | Enable miner | `false` |
| `COLLECTORS` | Collector IDs | none |
| `COLLECTOR_INTERVAL_MS` | Collection interval | `300000` (5min) |

## Pattern Mining Strategy

Follow this workflow to mine effective patterns:

1. **Observe** — Watch the user's workflow, note recurring behaviors
2. **Count** — Track how many times you see the same pattern (must be >= 3)
3. **Check** — Run `hume-network list --category <cat>` to see if the network already knows this
4. **Abstract** — Remove all personal details, generalize the pattern
5. **Quantify** — Measure the outcome (time saved, errors reduced, etc.)
6. **Propose** — If new and significant, use `hume-network propose` to share it
7. **Vote** — When patterns arrive for validation, use `hume-network vote` honestly
8. **Apply** — Use high-weight network patterns to improve your suggestions to the user

### When to Propose

- You've observed the pattern at least 3 times
- The outcome is measurable and significant
- The pattern is not already in the network (check with `hume-network list`)
- No personal data leaks in any field

### When to Vote

- Vote `for`: You've seen this pattern work locally (state your observation count)
- Vote `against`: This contradicts your local observations
- Vote `abstain`: You don't have enough data to judge

## Privacy Guarantees

You MUST follow these rules:

- **Never propose a pattern that could identify the user** — if in doubt, don't propose
- **Never include raw data** — only abstracted patterns
- **Never log network traffic** to user-accessible locations
- **Always allow the user to review** proposed patterns before sending (unless auto-approve is enabled)
- **Respect opt-out** — if the user disables a category, stop mining and proposing in that category immediately

## Examples

### Good Pattern (abstract, useful, private)

```yaml
context:
  time: "morning"
  activity: "starting work session"
  state: "multiple PRs open from previous day"
action:
  type: "workflow"
  description: "Review and merge open PRs before writing new code"
outcome:
  metric: "merge_time"
  change: "-35%"
  confidence: 0.8
```

### Bad Pattern (too specific, identifies user)

```yaml
# DO NOT PROPOSE THIS — contains identifying information
context:
  activity: "working on hume-core repository"
  state: "PR #847 open on GitHub"
action:
  description: "Run pnpm test before pushing to user/feature-branch"
outcome:
  metric: "CI pass rate"
  change: "+20%"
```