MatchBox Wiki

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.

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.

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.

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.

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.

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

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

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

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.

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

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.

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.

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

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

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

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

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

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

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.

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

{ 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.

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

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

{ 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.

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

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

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

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

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

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

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.

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.

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.

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.

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

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

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.

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.

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.

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.

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.

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).

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.

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.

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.

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.

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).

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

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.

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.

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.

No transcript ever crosses the Pi-harness boundary. Codex OAuth, the ChatGPT backend, any external inference path — all barred from seeing call content. Metadata (fund id, call id, rating) can travel over the wire for delivery purposes. Transcript bytes cannot.

Apple's Metal-accelerated ML framework — native on the Mac mini's M-series silicon. mlx_lm.server exposes an OpenAI-compatible /v1/chat/completions API on :8080; mlx_lm.lora handles per-fund adapter training; mlx_lm.convert handles HuggingFace → MLX quantisation. One Python environment for inference and training. Better memory efficiency than llama.cpp for fine-tuning.

Gemma 4 instruction-tuned, 4-bit MLX quant. Converted once via mlx_lm.convert --hf-path google/gemma-4-it -q --q-bits 4 and cached at ~/.hermes/models/gemma-base/. Served by mlx_lm.server on :8080. Safety floor — every fund without a fine-tune falls back here.

One LoRA adapter per fund at ~/.hermes/models/fund-<id>/. Trained only on that fund's corpus — a fund's adapter never sees another fund's calls. Loaded on demand by mlx_lm.server via --adapter-path ~/.hermes/models with a model alias (fund-f123, fund-f456, …). Optional mlx_lm.fuse bakes the adapter into a standalone fused model for faster cold loads.

analyzeWithFundModel(fundId, messages) in internal/providers/local-gemma.ts. Checks for a fine-tune by alias, falls back to the base model if none exists. Always a 127.0.0.1:8080 call — never leaves the host.

Corpus lives at ~/.hermes/corpora/fund-<id>/ in JSONL. Training: mlx_lm.lora --model gemma-base --train --data <fund-jsonl> --adapter-path <fund-dir> on the Mac mini's Metal GPU. Trigger: automatic at a call-count threshold (e.g. 25 analysed calls) or manual via matchbox finetune <fundId>. Output: ~/.hermes/models/fund-<id>/. Rotation: monthly; prior directory preserved as fund-<id>.v<N>/ for rollback.

internal/delivery/sanitiser.ts. Every outbound payload passes through it before hitting the Hermes delivery path. Strips transcriptExcerpt and the redFlags[].quote literal text. Only reason summaries and structured scores travel.

(1) analyzeTranscript may only call providers whose base URL is 127.0.0.1 or a Tailnet-scoped host. (2) internal/providers/openclaw-completions.ts is reserved for non-PII tasks (titles, settings probes) behind an explicit allowExternal: false flag on every call path. (3) Memory writes stay local — Honcho on the Pi harness; no Mem0 cloud ingestion for fund/founder facts.

Under the PII policy, OpenClaw is no longer the analyzer. Its continued role: non-PII tasks that don't carry transcript content — auto-title suggestions, Airtable-sync status probes, settings health checks. The allowExternal flag gates each call.

One model per fund. A fund's fine-tune never sees another fund's calls — training set is isolated per directory (corpora/fund-<id>/). Cross-fund insights happen in the Honcho fact graph (structured + scrubbed), not in the model weights.

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.

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.

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.

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.

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.

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).

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.

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.

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.

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.

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).

AutoAgent mutates what runs (analyzer.ts + prompt + validators). AutoResearch mutates what gets run against (per-fund Gemma fine-tune). Same closed SEPL loop (ρσιεκ), different target, different score function.

The MatchBox analyzer itself is an agent harness — it has a prompt, a tool surface, a validator chain. AutoAgent treats internal/signal/analyzer.ts as the mutation target, with program.md as the directive and tasks/ as the held-out benchmark. Meta-agent (Claude Code / Codex) runs locally with allowExternal=false.

Each fund's LoRA adapter directory at ~/.hermes/models/fund-<id>/ is a living artefact. AutoResearch mutates a fund-scoped finetune.config.json via RFC 6902 JSON Patch (LoRA rank, target modules, epochs, LR schedule, prompt template), retrains via mlx_lm.lora, scores against the fund's held-out corpus, and promotes the candidate adapter if it wins. One loop per fund, each loop isolated to its own corpus.

Human-authored directive at MatchBox repo root. The only file a human edits regularly. Constraints include no external inference, preserve JSON shape, keep transcript-excerpt truncation, and the F1 ≥ 0.85 target. Meta-agent re-reads every round.

Harbor-format held-out tasks. Each task: a transcript + an expected CallSignal shape (human-annotated rating, sentiment, red-flag categories). Gitignored — held-out transcripts never reach the remote. Public shareable tasks use synthetic, PII-free transcripts.

Mean F1 over four dimensions — sentiment accuracy · red-flag precision · coaching quality · founder-fit accuracy — evaluated against the held-out task set. Ship threshold: F1 ≥ 0.85 with no regression > 0.03 on any single dimension. All evaluation runs via the local Gemma — no external LLM sees the task set.

Append-only round log at repo root. One row per AutoAgent round: {round, score, patch, trajectory-diff, kept}. Gitignored. Sanitised before any literal transcript excerpt the meta-agent pasted into reflection notes gets committed.

Per-fund MLX fine-tune configuration. Keys mirror mlx_lm.lora options: lora_layers · lora_rank · lora_alpha · lora_dropout · target-module list · batch size · iters · learning-rate schedule · warmup · prompt-template fragments · base model hash. Mutated by AutoResearch via RFC 6902 JSON Patch so every change has a canonical reverse for rollback.

Fund-scoped F1 · coaching-tone match · red-flag precision against the fund's own held-out corpus. Promote threshold: candidate ≥ current by ≥ 0.02, with fund-specific partner sign-off required for promotion to production.

PII-adjacent, so NOT Cloudflare KV. Per-fund git repo at ~/.hermes/versions/fund-<id>/ — one commit per round with the JSON Patch + candidate config. Cross-fund manifest at ~/.hermes/versions/manifest.db (round · fund · score · patch-sha · model-sha · kept). Both on-host.

Meta-agent runs locally against the MatchBox repo. OpenClaw's allowExternal is false on every session. Tasks directory is gitignored. Trajectory logs are sanitised — the sanitiser strips any literal transcript excerpt the meta-agent may have pasted into its reflection notes before they land in results.tsv.

(1) No transcript ever reaches an external LLM — score computation runs against local Gemma only. (2) Per-fund tenancy — AutoResearch writes per fund; no fund's config sees another fund's data. (3) Reverse-patchable mutations (AutoResearch: RFC 6902; AutoAgent: git revert). (4) Score-gated commit — κ only promotes when objective improves AND safety invariants hold. (5) Evidence lives on-host; exportable as bundles if partners audit.

AutoAgent alone improves the harness but leaves each fund's base Gemma undifferentiated — matching quality caps at what the shared prompt can extract. AutoResearch alone improves per-fund models but can't fix a structurally bad analyzer. Together: harness extracts progressively sharper signal AND per-fund model learns the fund's voice, so each round of each loop makes the other's next round easier.

v1 Signal — AutoAgent scaffolding (program.md · tasks/ · local Harbor runner) + one synthetic-data round. v1 + first fund past the 25-call threshold — AutoResearch loop triggers for its first real per-fund fine-tune. v2 Matching — matching quality is a direct function of both loops' output. v3 Founder Prep — AutoAgent target surface expands to include the avatar-interview harness; AutoResearch gains pre-call screening as a third eval dimension.

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

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

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

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

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

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

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

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

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