White Paper 2 of 3 — Technical Architecture | MasteryMade / Forge Infrastructure | April 2026

Intelligence Hub: Technical Architecture

How the compilation pipeline works, what it connects to, and how it's built.

System Overview

The Intelligence Hub is NOT a new service. It's a compilation pipeline — a set of Python scripts, Claude Code hooks, and source adapters that wire together existing Forge infrastructure. No new databases. No new ports. No new services to maintain.

Architecture Diagram

CAPTURE LAYER (automatic, zero-effort)
  Claude Code Hooks          Ralph Post-Task         Timers
  ├─ SessionEnd → flush.py   ├─ ralph-flush.sh       ├─ intel
  ├─ PreCompact → flush.py   └─ writes to daily/     ├─ decisions
  └─ SessionStart → inject                            └─ transcripts
       context from index.md

       ┌─────────────┐  ┌─────────────────┐
       │   daily/     │  │   raw/           │   IMMUTABLE
       │   session    │  │   intel/         │   APPEND-ONLY
       │   logs       │  │   decisions/     │   SOURCE OF TRUTH
       └──────┬──────┘  └────────┬────────┘
              │                   │
              ▼                   ▼
COMPILATION LAYER (LLM-driven, incremental)
  compile.py
  ├─ Reads: AGENTS.md + existing articles + new sources
  ├─ Uses: Claude Agent SDK (Max) or Groq (extraction)
  ├─ Writes: knowledge/ articles + KFS dual-write
  └─ State: SHA-256 hashes, incremental only

       ┌──────────────────────────────────┐
       │   knowledge/                      │
       │   ├─ index.md    (master catalog) │
       │   ├─ concepts/   (knowledge)      │  ──DUAL-WRITE──▶ KFS (5012)
       │   ├─ connections/ (synthesis)      │                    │
       │   ├─ qa/          (filed answers) │                    ▼
       │   └─ projects/    (state)         │              Graphiti (5022)
       └──────────────────────────────────┘

QUERY + FILE-BACK LAYER
  hub-query.sh "question" [--file-back]
  ├─ Reads index → selects articles → synthesizes answer
  └─ With --file-back: creates Q&A article (system gets smarter)

LINT LAYER (daily auto, weekly deep)
  lint.py
  ├─ 6 structural checks (free)
  ├─ 1 graph check via Graphiti gaps endpoint (free)
  └─ 1 semantic check for contradictions (weekly, LLM)

The Four Operations — Technical Detail

1. INGEST: Zero-Effort Capture

Every source has an automatic trigger — no manual step required:

All adapters normalize to a common markdown format with YAML frontmatter (source_type, source_id, agent_id, vault_id, timestamp). Downstream, the compiler doesn't know or care where a source came from.

2. COMPILE: The Core Pipeline

The compiler (compile.py) is the heart of the system. It reads raw sources and transforms them into structured, interlinked knowledge articles.

1. Reads AGENTS.md (compiler specification — defines article types, quality thresholds, linking rules)
2. Reads knowledge/index.md (current article catalog)
3. Reads all existing articles into context (fits at Tier 1 scale, <200 articles)
4. Reads the new daily log or raw source to compile
5. Calls Claude Agent SDK with tools (Read, Write, Edit, Glob, Grep)
6. The LLM directly creates/edits files — concept articles, connection articles, updates to existing articles
7. After file writes: dual-write to KFS via POST /v1/ingest/event

Four Article Types

3. QUERY: The Compounding Loop

Any script, agent, or human can query the compiled knowledge base:

hub-query.sh "What patterns exist in our dashboard builds?"
hub-query.sh "What did we decide about auth?" --file-back --json

With --file-back, the answer is saved as a Q&A article in knowledge/qa/, updates the index, and dual-writes to KFS. Every question makes the system smarter. This is the compounding mechanism.

Ralph's session-zero will call hub-query.sh "What do we know about <project>?" before starting any task — giving it compiled context from all prior sessions, decisions, and patterns.

4. LINT: Self-Correction

Lint uses Graphiti's existing /v1/expert/*/gaps endpoint for gap detection — the graph finds structural holes that text analysis can't. This is a capability no flat-wiki system has.

The Three-Layer System: How It Fits Together

Dual-Write: Filesystem + KFS

Every compiled article exists in TWO places, each optimized for different access patterns:

Cost Model

Scale Path

Tier 2 infrastructure already exists (Supabase pgvector + KFS semantic search). The dual-write means articles already have embeddings. Transitioning is adding a search step, not a migration.

Build Phases

Total: ~10 Ralph-hours. Most of the work is wiring existing infrastructure, not building from scratch.

Published by Forge Intelligence Hub project · April 2026 · MasteryMade infrastructure