MatchBox Wiki

// LLM knowledge base for Organized-AI/MatchBox — founder/VC matching engine

How to use this wiki (for humans and LLMs) Every MatchBox concept has one node. Stable #id, type badge, one-paragraph description, chips to deps. MatchBox is a fork of ClawBox with the Signal feature bolted on — load the ClawBox wiki first for the base surface (Tauri / React / Bun / routes), then this wiki for what's new (Signal UI · FundProfile + CallSignal data model · Airtable sync · analyzer). Repo default branch: claude/founder-fund-matching-urzts.
 ┌─────────────────── MATCHBOX ───────────────────┐
 │                                                │
 │   v1 SIGNAL (shipping)                        │
 │      transcribe → sentiment · fit · red flags  │
 │      coaching-for-VC · call rating             │
 │                                                │
 │   v2 MATCHING (next)                         │
 │      founder ↔ fund pairings                   │
 │      cross-network deal sharing                │
 │                                                │
 │   v3 FOUNDER PREP (later)                    │
 │      AI avatar interview · due diligence       │
 │                                                │
 └────────────────────┬───────────────────────────┘
                      ▼
       delivered as an agent into Slack · WhatsApp · email
                      │
                      ▼
           Crowley Capital seed node · Jon Forbes primary
 // end-to-end system · dual runtime

                     ┌──────────────────┐
                     │ AIRTABLE intake  │ founders sign up
                     └────────┬─────────┘
                              │ sync via /api/signal/airtable/sync
                              ▼
  VC ── Zoom/phone ──▶ transcript ──▶ SignalView (React) ──▶ POST /api/signal/calls
                                                                         │
                                                                         ▼
                                                   Bun/Hono backend · :13000
                                                                         │
                              ┌──────────────────────────────────────────┤
                              ▼                     ▼                    ▼
                      ┌──────────────┐     ┌───────────────────┐  ┌─────────────┐
                      │ OPENCLAW     │     │ HERMES            │  │ local store │
                      │ analyzer     │     │ memory + delivery │  │ CallSignal[]│
                      │ one-shot JSON│     │ Honcho · skills   │  │ FundProfile[]│
                      └──────┬───────┘     └─────────┬─────────┘  └──────┬──────┘
                             │                       │                   │
                             ▼                       ├──▶ Slack          │
                        CallSignal                   ├──▶ WhatsApp       │
                             │                       ├──▶ email          │
                             │                       └──▶ nightly digest │
                             └─────────┬─────────────────┬────────────────┘
                                       ▼                 ▼
                                       fact writes       GET /api/signal/calls
                                            ▼                 ▼
                                   ~/.hermes/memories/    SignalView renders

Product

v1 · Signalphase

Shipping surface today. Turns each VC-founder call into a structured CallSignal — rating, sentiment, red flags, coaching notes, fact-finding prompts for the next call. Captures the training corpus for v2 matching.

v2 · Matchingphase

The engine the product is named for. High-confidence founder ↔ fund pairings built from v1's training corpus plus Airtable intake. Cross-network deal sharing between subscribed funds. Match quality compounds fund-over-fund.

v3 · Founder Prepphase

AI avatar conducts the initial founder interview. Automated screening before the VC spends a minute. Due-diligence layer that cuts fraudulent claims and poor-fit calls.

strategystrategy

Upgrade a working 7/10 VC workflow into the 10/10 industry benchmark by wiring MatchBox into the partner fund's existing process. No forced platform migration.

agent-not-platformdelivery

MatchBox ships as an agent reachable where the VC already works — Slack, WhatsApp, email. The Tauri desktop shell in this repo is the internal operator surface; partner funds don't have to adopt it to get value.

curated VC networkmoat

Subscribed funds share high-confidence deals; the corpus grows, matching quality grows. Crowley Capital is the seed node. Closes the industry due-diligence gap.

People

Jakeperson

Business lead. Owns the Forbes relationship and the Friday compensation meeting. Runs founder intake through the Airtable form.

Jordanperson

Technical lead. Owns technical guides, development assets, and the Signal/Matching delivery surface. This wiki + the matchbox-guide are two of those assets.

Jon Forbespartner

Primary rollout partner at Crowley Capital. Proven software funding pipeline and infrastructure; wants to expand into ambiguous industries. MatchBox plugs in as the matching + signal layer on top of his existing deal flow.

Crowley Capitalfund

Seed node for the MatchBox network. Anchor fund for the case study. crowley-capital.com.

Forbes-first rolloutstrategy

Non-exclusive case-study rollout: Forbes first, other funds follow on subscription once the pattern is proven. Revenue model in negotiation — revenue share, deal participation, or subscription.

revenue model (open)business

Three options on the table: (1) revenue share on portfolio companies uplifted by MatchBox, (2) participation in successful post-implementation deals, (3) monthly subscription for network access by other funds. Terms finalised in the Friday meeting.

External surfaces

 // delivery fanout · CallSignal → where partner funds actually see it

                                CallSignal
                                     │
                                     ▼
                       internal/delivery/hermes.ts
                                     │
                                     ▼
                     Hermes gateway (Pi harness)
                     ai.hermes.gateway · claws-mac-mini
                                     │
          ┌──────────┬────────┬──────┼─────────┬──────────────────┐
          ▼          ▼        ▼      ▼         ▼                  ▼
        Slack    WhatsApp  Telegram  email    SMS          cron digest
      Socket Mode   Business   bot   SMTP/Gmail  provider        nightly →
   @claude_code_    API       gateway   MCP       bridge        Crowley Slack
       slack                                                      channel

                                     │
                                     ▲
                                     │
                              Hermes cron scheduler
                              0 9 * * * style expressions
                              per-run cost cap · pause/resume
Airtable founder intakeform

Live founder-signup form. Rows sync into MatchBox's fund store via POST /api/signal/airtable/sync. airtable.com/appQJ4zSchyLKGYd4/shrVPWhw0QnhgIaDs.

Granola strategy calldoc

Canonical source for MatchBox positioning. notes.granola.ai/t/b9784c0c-…. README draws from here.

Slack deliverysurface

Coaching notes + call ratings posted directly into the fund's working channel. First delivery surface after the operator UI.

WhatsApp deliverysurface

Same signal, delivered where the partner already texts with founders.

Email deliverysurface

Follow-up + next-call prompts surfaced alongside the VC's existing thread.

OpenClaw Gatewaydep

Separate process (http://127.0.0.1:18789/v1). MatchBox's analyzer routes LLM calls through it via callOpenclawDefaultModelChatCompletion — inherited from the ClawBox base.

Signal data model

 // per-call request flow · one POST → one CallSignal + two side-effects

  SignalView  ──▶  POST /api/signal/calls { fundId, founderName, callDate, transcript }
                                                 │
                                                 ▼
                              internal/routes/signal.ts
                                                 │
                                                 ▼
                 analyzeTranscript(fund, transcript)   internal/signal/analyzer.ts
                                                 │
                                                 ▼
              callOpenclawDefaultModelChatCompletion()   via OpenClaw gateway
                                                 │
                                                 ▼
      parse JSON · clampScore · parseRedFlags(max 8) · parsePrompts(max 8)
                                                 │
                                                 ▼
                       CallSignal (rating, sentiment, redFlags,
                                   factFindingPrompts, coachingForVc,
                                   summary, transcriptExcerpt ≤4000)
                                                 │
           ┌─────────────────────────────────────┼─────────────────────────────┐
           │                                     │                             │
           ▼                                     ▼                             ▼
   fire-and-forget                 persist in                   fire-and-forget
   Hermes memory write               internal/signal/index        Hermes delivery
   (signal-memory.ts)                                             (delivery/hermes.ts)
           │                                     │                             │
           ▼                                     ▼                             ▼
   Honcho facts keyed by         200 { call: CallSignal }           Slack / WhatsApp /
   fund · founder · sector                                          email / digest
                                                 │
                                                 ▼
                              zustand store ──▶ SignalView re-render
FundProfiletype

One row per fund. Fields: id · name · thesis · stage · checkSize · sectors[] · redFlags · notes · source ('manual' | 'airtable') · airtableRecordId? · createdAtMs · updatedAtMs. Source of truth lives in internal/signal/index.ts; Airtable sync writes the airtable-source rows.

CallSignaltype

One row per analysed call. Fields: id · fundId · fundName · founderName · callDate · transcriptExcerpt · rating · sentiment (SentimentScores) · redFlags[] · factFindingPrompts[] · coachingForVc · summary · model? · createdAtMs. Produced by analyzeTranscript.

SentimentScorestype

{ enthusiasm, thesisAlignment, concern } — three dimensions, each a number in [0, 10], rounded to 0.1. Clamped by clampScore() in the analyzer; bad values fall back to a passed default.

RedFlagHittype

{ quote, reason } pair. Quote must be a literal excerpt from the transcript; reason is the analyst note. Capped at 8 per call.

AirtableConfigViewtype

{ apiKey (masked), hasApiKey, baseId, tableName, viewName }. apiKey is returned as •••••• so the UI can display it without exposing the full key.

AnalyzeCallInputtype

{ fundId?, founderName, callDate, transcript }. Posted to POST /api/signal/calls. Transcript excerpt gets truncated to 4000 chars on the route side for storage; the analyzer sees up to 20,000 chars.

signal store (zustand)store

Client state at src/store/signal.ts: funds · calls · airtable config · loading / syncing / analyzing flags · error. Actions: loadFunds, syncAirtable, analyzeCall, fund CRUD, call delete.

signal service (fetch client)client

src/services/signal.ts. Thin fetch wrapper targeting http://127.0.0.1:13000. Exposes signalApi with getAirtableConfig, updateAirtableConfig, syncAirtable, fund CRUD, analyzeCall, deleteCall.

Backend — internal/routes/signal.ts

GET · PUT /api/signal/airtableroute

Read or patch the Airtable config. API key returned masked. PUT supports clearApiKey: true to wipe it.

POST /api/signal/airtable/syncroute

Fetch rows from the configured Airtable base / table / view, upsert into the fund store as source: 'airtable'. Returns { success, synced }. Implementation: internal/signal/airtable.tssyncFundsFromAirtable(cfg).

GET · POST · PUT · DELETE /api/signal/fundsroute

Manual fund CRUD. Coexists with the Airtable-sourced rows. POST assigns a nanoid and stamps timestamps.

GET · POST · DELETE /api/signal/callsroute

Call list + analyze + delete. POST accepts AnalyzeCallInput, calls analyzeTranscript(), stores the CallSignal with a transcriptExcerpt truncated to 4000 chars.

analyzeTranscript()function

internal/signal/analyzer.ts. Builds the prompt from the FundProfile + transcript, calls callOpenclawDefaultModelChatCompletion, parses + validates the JSON response. Score clamping, red-flag cap (8), prompt cap (8), transcript truncated to MAX_EXCERPT_CHARS = 20000 with an explicit "truncated N chars" footer.

callOpenclawDefaultModelChatCompletionfunction

Inherited from ClawBox. Routes the LLM call through the local OpenClaw Gateway using the user's configured default model. No provider key in MatchBox itself — model choice lives in the Gateway.

inherited routesroutes

Agents · channels · chat · config · cron · models · onboard · sessions · skills · soul · titles · tools. All from the ClawBox base — see the ClawBox wiki for per-route detail.

Frontend surface

 // repo module map · ★ = MatchBox-specific (rest inherited from ClawBox)

  matchbox/
  │
  ├── src/                                FRONTEND — React 18 + Vite · dev :14200
  │   ├── components/
  │   │   ├── SignalView.tsx    ★         v1 operator UI (funds + calls + Airtable)
  │   │   ├── ChatView · OnboardView · SettingsView · …     inherited
  │   │   └── chat/ · layout/ · plugins/ · sidebar/ · …     inherited
  │   ├── services/signal.ts      ★         fetch client → http://127.0.0.1:13000
  │   ├── store/signal.ts         ★         zustand state (funds · calls · airtable cfg)
  │   └── types/signal.ts         ★         FundProfile · CallSignal · SentimentScores …
  │
  ├── internal/                           BACKEND — Bun + Hono · :13000
  │   ├── routes/
  │   │   ├── signal.ts          ★         Airtable config · funds CRUD · calls analyze
  │   │   └── agents/channels/chat/config/…  inherited (12 modules)
  │   ├── signal/                ★
  │   │   ├── index.ts                       store (funds + calls + airtable cfg)
  │   │   ├── airtable.ts                    syncFundsFromAirtable(cfg)
  │   │   └── analyzer.ts                    analyzeTranscript → OpenClaw
  │   ├── providers/
  │   │   ├── openclaw-completions.ts        (existing) analyzer path
  │   │   └── hermes-client.ts  ★ NEW    memory write + delivery path
  │   ├── memory/                ★ NEW
  │   │   └── signal-memory.ts              Honcho fact writes on every CallSignal
  │   └── delivery/              ★ NEW
  │       └── hermes.ts                     Slack / WhatsApp / email / digest fan-out
  │
  ├── src-tauri/                          TAURI v2 SHELL — Rust · OS integration
  ├── scripts/                              mock-gateway · smoke · sign-win · …
  ├── docs/                                 dependency-policy · openclaw-compat · releasing
  ├── public/ · test/
  └── package.json                          (still named "clawbox" · v2026.3.17)
SignalViewview

Single top-level component at src/components/SignalView.tsx. The v1 operator UI. Fund list + Airtable config + call analysis workspace. Reads state from signal-store; dispatches via signal-service.

inherited viewsviews

ChatView · CronView · OnboardView · PluginsView · SettingsView · SkillsView · SoulView · StartupScreen · GatewayRestartBanner · LanguageToggle · ThemeToggle · TypewriterText · SuggestedQuestions — all from the ClawBox base. See clawbox-wiki #views.

Concepts

signal (the noun)idea

The output of a call: a structured CallSignal. Legible (ratings + quotes), portable (JSON), actionable (coaching + prompts). Not just a transcript — a decision aid.

match (v2 deliverable)idea

A high-confidence pairing between a founder and a fund, justified by the call signal + intake data. Not a thesis-keyword search — a score-weighted recommendation.

v1-as-training-datadesign

Every analysed call feeds v2. The Signal phase is deliberately capturing labeled signal (rating + sentiment + red flags) so the matching model has real data before it's trained.

due-diligence gapthesis

Industry-wide: founders inflate claims, VCs burn partner time on poor matches. MatchBox closes the gap with the AI avatar screen in v3 and the red-flag capture in v1.

fork of ClawBoxlineage

MatchBox inherits the Tauri + React 18 + Bun/Hono + OpenClaw client base from ClawBox. package.json still reports name: clawbox. Cleanup is on the follow-up list; until then, everything in the ClawBox wiki applies to the base surface.

Runtime choice — OpenClaw vs Hermes

the only real couplingdesign

internal/providers/openclaw-completions.ts — one file, one function (callOpenclawDefaultModelChatCompletion). That's the sole tight link to OpenClaw. Everything else in MatchBox is provider-agnostic. A swap is a provider-module rewrite, not an application rewrite.

OpenClaw (current)runtime

ClawBox-family backend. Purpose-built for desktop client + portable-vs-system local runtime. Defined minimum RPC surface (models.list, sessions.*, chat.*, config.*) with a mock gateway for smoke tests. Supports the broader OpenClaw-family portfolio (ClawBox, MatchBox, any future desktop products).

Hermes (alternative)runtime

Nous Research agent runtime. Agent-native (session loops, memory, skills hub). Deployed on claws-mac-mini as the Pi harness — launchd-supervised, Codex OAuth primary, Gemma-4 fallback, MCP-native, cron built in. Platform adapters for Slack / WhatsApp / Telegram / Discord / email are first-class.

path A · full swapoption

Replace openclaw-completions.ts with a Hermes equivalent. ~200 LOC. Also update internal/compatibility.json, GatewayRestartBanner, the onboarding wizard's runtime probes, and SettingsView's gateway URL field. ClawBox-family scaffolding fights you a little.

path B · hybrid (recommended)option

Keep OpenClaw for the analyzer. Add Hermes as a peer for delivery — post CallSignal output into Slack / WhatsApp / email where Hermes's adapters are best-in-class. New module internal/delivery/hermes.ts + new route POST /api/signal/calls/:id/deliver. No existing code replaced.

Hermes prospros

Platform delivery is native · already running on claws-mac-mini (reuse Pi harness infra) · entitlement-funded inference via Codex OAuth + Gemma fallback · Honcho/Mem0 memory system for v2 Matching · MCP-native (Airtable · Gmail · CRM MCPs plug in) · skills hub + learning loop maps onto v3 Founder Prep · cron scheduler built in.

Hermes conscons

Rewrites ClawBox inheritance (onboarding wizard · SettingsView · PluginsView · GatewayRestartBanner · compatibility.json) · API shape mismatch (Hermes is a session runtime, analyzer wants one-shot JSON) · loses mock-gateway dev ergonomics · support boundary blurs (MatchBox inherits self-heal concerns) · delays Forbes rollout · partner self-host harder (Python venv vs npm).

OpenClaw prospros

Already working · purpose-built for desktop-client + local-runtime · consistent with the ClawBox-family portfolio · defined minimum RPC surface with a testable mock gateway.

OpenClaw conscons

Delivery channels supported but not deployed at Hermes's scale · no persistent memory out of the box (more custom work for v2/v3) · no entitlement-funded inference path.

phased plan — dual runtime from v1decision

v1 Signal — OpenClaw analyzer unchanged + Hermes joins as memory substrate and delivery peer. v2 Matching — matching engine queries the Hermes memory graph; corpus is already deep from v1 writes. v3 Founder Prep — avatar interview writes founder-side facts into the same graph. OpenClaw → Hermes full consolidation is optional at this point and cheap.

"start writing to memory before you need it"heuristic

You can't retroactively populate Honcho with calls that already happened. Every day MatchBox runs without Hermes memory is a day of corpus loss. OpenClaw stays because it works; Hermes joins in v1 because memory is the whole product thesis.

Memory layer (Hermes)

 // memory write + query · how a CallSignal becomes a matchable fact graph

  WRITE PATH — every analysed call

     CallSignal (id=c789, fundId=f123, founderName="Alice Kim", rating=7.8)
            │
            ▼
     signal-memory.write(signal)               internal/memory/signal-memory.ts
            │
            ▼
     structured facts ──────▶ Hermes Honcho
       fund:f123/thesisAlignment/sector:fintech/stage:seed = 8.2
       fund:f123/coachingTone = "pragmatic-over-visionary"
       founder:"Alice Kim"/redFlagPattern/regulatory = "we'll ignore SOC2 until Series A"
       founder:"Alice Kim"/enthusiasm = 9.1
       call:c789/summary · /rating=7.8 · /model=gpt-4 · /callDate=2026-04-22
            │
            ▼
     persisted in ~/.hermes/memories/  on claws-mac-mini


  READ PATH — later, when v2 matching (or a v1 suggestion panel) asks

     GET /api/signal/memory/suggestions?founderName=Alice Kim
            │
            ▼
     Hermes Honcho query — "which funds:
       • have thesisAlignment[sector:fintech][stage:seed] > 7
       • AND coachingTone compatible with founder's enthusiasm style
       • AND do NOT flag regulatory risk as blocker
       • AND haven't seen Alice in the last 30 days"
            │
            ▼
     ranked match candidates  [{ fund, score, reason-chain }, …]
            │
            ▼
     SignalView panel — "What else does this fund care about?"
     visible in v1 before v2 formally ships
memory-as-cornerstonethesis

A matching engine without durable cross-call memory is just a sentiment scorer. The non-obvious connections between funds and founders only surface once the corpus is deep — fund X's regulatory allergy, founder Y's second-call improvement, three founders flagging the same market signal. None of that is visible in a single CallSignal. All of it is visible in Hermes memory.

Hermes Honcho / Mem0store

Dialectic memory system inside Hermes (optional Mem0 augmentation). Keyed facts, not raw transcripts. Lives on the Pi harness at ~/.hermes/memories/. Reachable via the same gateway that runs the Slack Socket Mode app.

fact schema (v1)schema

Minimum v1 shape. Lock before the first production call; version it so v2 matching knows what to expect. fund:<id>/thesisAlignment/sector:<s>/stage:<t> = N · founder:<name>/redFlagPattern/<pattern> = quote · fund:<id>/coachingTone/<style> · call:<id>/summary · /rating · /model · /callDate.

internal/providers/hermes-client.tsmodule

Thin client to the Hermes gateway. Mirrors the shape of openclaw-completions.ts but targets ai.hermes.gateway on claws-mac-mini. Bearer-auth via a token stored alongside existing gateway secrets.

internal/memory/signal-memory.tsmodule

Memory write layer. Hooks into POST /api/signal/calls; after the analyzer returns a CallSignal, fires a fire-and-forget Honcho write with the fact set defined in memory-schema. Write errors must not block the user — Hermes is additive, not critical-path for v1 demo.

GET /api/signal/memory/suggestionsroute

Query route. Accepts fundId, founderName, or a sector/stage pair. Queries Hermes Honcho for cross-call patterns and returns ranked match candidates. Available for UI surfacing from v1 (before v2 matching formally ships).

internal/delivery/hermes.tsmodule

Routes a CallSignal into Slack / WhatsApp / email via Hermes's platform adapters. Reuses the same hermes-client.ts as the memory write path — one runtime, two responsibilities.

settings (additive)config

New fields in SettingsView: Hermes gateway URL + bearer token + per-fund delivery channel id. Backwards-compat: if unset, delivery is skipped and memory writes are a no-op — preserves the current OpenClaw-only flow for tests and the Forbes demo fallback.

nightly memory-graph digestcron

Hermes cron job on the Pi harness runs nightly. Emits a memory-graph digest into the Crowley Capital Slack channel: new patterns, promoted candidates, fact-count growth. Uses Hermes's built-in cron scheduler — no custom scheduler needed.

risks to watchrisk

Schema drift — v1 writes are v2's reads; lock + version. PII / confidentiality — memory now holds partner-fund + founder data; audit the storage + access paths on the Pi harness. Silent back-pressure — fire-and-forget writes hide failures; monitor the Hermes errors log as MatchBox ops. Dual config — two gateways, two failure modes; document both in SettingsView.

what this preservesinvariant

Forbes-demo safety (OpenClaw analyzer unchanged · Hermes outage degrades to current behaviour) · mock-gateway dev loop (Hermes writes are no-ops when the URL isn't configured) · ClawBox inheritance (onboarding, SettingsView, PluginsView stay wired to OpenClaw) · support boundary clarity (OpenClaw bugs = client path · Hermes bugs = memory path).

Commands

npm run devcmd

Frontend (:14200) + backend (:13000) together. Inherited from ClawBox.

npm run tauri:devcmd

Full desktop shell under Tauri. Includes the Signal view + all inherited surfaces.

npm run build:frontend · build:backend · cargo checkcmd

Three-step build: tsc -b && vite build, Bun bundle, Cargo sanity on src-tauri/Cargo.toml.

scan:repo · audit:licenses · audit:deps · smoke:backendcmd

Standing audits + the lightweight smoke test via scripts/mock-gateway.mjs. All inherited from ClawBox.

openclaw gateway run --dev --auth none --bind loopback --port 18789cmd

Spin up the OpenClaw Gateway for local MatchBox dev. The analyzer routes through this.

Related guides

matchbox-guideguide

Human-readable operator guide. Tabs: Overview · Strategy · Product Phases · Signal (v1) · Architecture · Delivery · Dev · Ops · Stakeholders.

clawbox-guide / clawbox-wikiguide

The base project MatchBox forked from. All non-Signal internals — backend routes, frontend views, onboarding wizard, build chain — trace back here.

openclaw-wiki / openclaw-educationguide

The OpenClaw Gateway MatchBox depends on for LLM calls. Any model-routing question lives here.

organized-market-archguide

Organized Market is the broader Organized AI project that MatchBox participates in. Sibling components include ClawBox (desktop surface) and OpenClaw (personal AI control plane).