Build a brain that gets smarter.

Three pillars. Miss any one and you're back to a briefing bot. Together they compound.

Why stateless briefings plateau

A read-email-and-summarize bot is exactly as good on day 100 as on day 1, because it keeps no state and learns nothing. The moment you add durable memory + relationships + feedback, day 100 is dramatically better than day 1 — and the gap widens. The asset isn't the code; it's the accumulated, connected, feedback-tuned data underneath it. Time becomes a moat you can't be shortcut on.

Build it on any stack

The pattern is portable. Minimum viable version:

• Store: any database (SQLite, Postgres, even files) with a memories/facts table — content, type, tags, importance, timestamps.
• Semantic recall: add vector embeddings so the system retrieves by meaning, not keywords.
• Graph: a relational/graph layer (a dedicated graph DB, or graph-style edges in SQL) for traversal — "show me everything connected to X."
• Loop: a feedback channel (a reaction, a rating, a "used/not used" signal) that writes back into the store and re-ranks future output.
• Cadence: a scheduled job that ingests → updates memory + graph → runs the improvement pass → delivers.

Open Brain is further along than most people realize. It already has persistent Postgres memory, semantic search, and a real, typed, time-aware knowledge graph. The one pillar it hasn't closed yet is the self-improvement loop — the feedback signal that re-ranks what gets surfaced based on what actually worked. Here's the honest map, then the recipes, built in OB1's existing extension/recipe format.

Recipe 1 — Traverse the graph you already have

Because OB1's graph lives in plain Postgres tables (thought_edges, edges, graph_edges), multi-hop "everything connected to X" is a recursive query — no new engine, no migration. This recipe ships the traversal helpers OB1 doesn't bundle yet, respecting the temporal-validity columns so decayed edges drop out automatically.

-- "Everything connected to a thought, up to 3 hops,
--  skipping edges that have decayed out (valid_until set)."
WITH RECURSIVE connected AS (
  SELECT to_thought_id AS id, relation, 1 AS hop
  FROM thought_edges
  WHERE from_thought_id = :start_id
    AND valid_until IS NULL
  UNION ALL
  SELECT e.to_thought_id, e.relation, c.hop + 1
  FROM thought_edges e
  JOIN connected c ON e.from_thought_id = c.id
  WHERE c.hop < 3
    AND e.valid_until IS NULL
)
-- DISTINCT ON keeps one row per thought at its nearest hop
SELECT DISTINCT ON (t.id) t.*, c.hop
FROM connected c
JOIN thoughts t ON t.id = c.id
ORDER BY t.id, c.hop;

Recipe 2 — The self-improvement loop

The genuinely missing pillar. A lightweight extension that captures a feedback signal on anything OB1 surfaces, writes it back, and re-ranks future retrieval + output.

CREATE TABLE IF NOT EXISTS feedback_signals (
  id            bigserial PRIMARY KEY,
  thought_id    bigint REFERENCES thoughts(id),
  signal        text NOT NULL,          -- 'used' | 'dismissed' | 'loved' | 'wrong'
  weight        real NOT NULL DEFAULT 1,
  note          text,
  created_at    timestamptz DEFAULT now()
);

-- A retrieval view that boosts what's worked before
CREATE OR REPLACE VIEW ranked_thoughts AS
SELECT t.*,
  coalesce(sum(f.weight) FILTER (WHERE f.signal IN ('used','loved')), 0)
  - coalesce(sum(f.weight) FILTER (WHERE f.signal IN ('dismissed','wrong')), 0)
  AS feedback_score
FROM thoughts t
LEFT JOIN feedback_signals f ON f.thought_id = t.id
GROUP BY t.id;

Recipe 3 — Hybrid recall (vector × graph × feedback)

Tie the three together: a retrieval primitive that blends semantic similarity (pgvector, already there), graph proximity (the traversal in Recipe 1, over edges already there), and feedback score (Recipe 2, the one new piece) into a single ranked context payload. This is the whole methodology expressed as one OB1 query path — and it's what turns "Open Brain" from a brain that stores into a brain that learns.

You don't need a cloud or any particular product to run this. The entire methodology fits on a single always-on computer you own — a Mac Mini in the corner, a spare laptop, a mini PC, even a Raspberry Pi. That's exactly how the system behind the daily briefs runs: a Mac Mini that never sleeps. Here's the blueprint, mapped to the three pillars.

Why own the box