PAM — Relational Brain for Personal Administration

The Problem

Personal admin is the last category where the work lives entirely in your head.

Finance apps solved "what did I spend?" Nobody has solved "what am I supposed to have, and what am I missing?" The gap between what exists and what's required creates real harm: penalty notices, insurance denials, platform delistings, legal complications. The system should know before you do.

$2K–$15K

Average penalty for a missed tax filing deadline

23%

STR operators running on expired licenses nationally

3.4 hrs/wk

Time spent on personal admin (founders: 6–10 hrs)

Capability 1

Entity Graph

Every property, vehicle, account, insurance policy, venture, and government relationship is a first-class object with a lifecycle state. When a property is sold, the required documents change. When a business is dissolved, different filings apply. The graph maintains the map — you just update state.

🏠

Properties

residential, commercial, STR

🚗

Vehicles

registration, insurance, title

🏦

Accounts

checking, credit, brokerage

🛡️

Policies

auto, health, life, umbrella

🏢

Ventures

LLC, corp, sole prop

🏛️

Government

IRS, state tax, DMV

❤️

Health

providers, records, benefits

🔄

Lifecycle States

active, closed, sold, dissolved

Architecture

Four Subsystems

🗺️ Entity Graph

First-class objects with lifecycle states, subtypes, identifiers, and many-to-many document links. State changes cascade new requirements automatically.

📄 Document Ingestion

Storage-agnostic pipeline: Source Adapter (Google Drive first) → Claude API classifier → entity linking → staging for approval. Semi-automated, human-in-the-loop.

⚡ Gap Engine

Lifecycle rules × entity states × linked documents = computed gaps. URGENT / MISSING / STALE / COMPLETE. Gaps are never stored — always computed on demand.

🔗 Share Links

Time-limited, field-scoped read-only access. 16-byte URL-safe tokens. Identifiers and notes hidden by default. The proto-TOTEM delegation layer.

Backend

Python 3.11+, FastAPI, Jinja2 + HTMX

Database

SQLite (WAL mode, foreign keys on)

AI Layer

Claude API classifier with heuristic fallback

Deployment

Fly.io (persistent volume) + Cloudflare Pages

🔒 Metadata-only by default. PAM never reads document contents — only filenames, folder paths, and file stats. Content-aware matching requires explicit user permission.

The Differentiator

How the Gap Engine Works

Three inputs, one output. The gap engine computes the diff between what lifecycle rules require for each entity in its current state, and what's actually linked. You don't maintain a to-do list — PAM computes it from the graph.

Input 1

Lifecycle Rules

entity_type + entity_status → required docs, deadlines, recurrence

×

Input 2

Entity States

active, sold, closed, dissolved — each state activates different rules

×

Input 3

Linked Documents

what's actually classified, linked, and current for each entity

→

Output

Computed Gaps

Urgent

Deadline within 30 days

Missing

Required document not found

Stale

Document exists but outdated

Complete

All requirements met

Lifecycle Cascades

Selling a property doesn't stop tracking — it activates a different set of requirements.

State Change

Property: owned → sold

→

Old Rules Retired

Insurance, tax assessment

→

New Rules Activated

1099-S, closing statement

→

New Gaps Computed
Schedule D, capital gains

Working Product

Five Views, Live on Fly.io

📊 Dashboard

Entity counts, top gaps (urgent first), recent ingestions. The daily command center.

🗂️ Entities

List/filter entities, detail view with linked documents and active gaps per entity.

⚠️ Gaps

Full gap report. Filter by entity, urgency, tax year. The actionable output.

📋 Triage

Classifier dry-run results with approve/reject/edit controls. Human-in-the-loop staging.

Thesis Fit

Inversion #3: Trust

"You Are an API" — legibility earns trust. PAM shows users exactly what the system knows about them: every entity, every linked document, every computed gap. Nothing hidden, nothing inferred without evidence. The user is the authoritative source, not the system.

Wherewithal Ventures — Business Model Inversion thesis

Layer 2: Reflective

PAM is the reflective layer of the user model — it shows users what the system knows about them and lets them correct it. The progressive classifier cascade (L0–L3) maps to the ambient → reflective → directed → marketplace layer model.

Metadata-Only

PAM classifies from filenames and folder structure, never document contents. This isn't a limitation — it's the trust architecture. Content access requires explicit permission, per-document or global.

Share Links = Proto-TOTEM

Field-scoped, time-limited delegation. The precursor to Totem's full credential delegation engine. PAM proves the pattern before Totem scales it across agents.

Roadmap

Built vs. Planned

Signal

Founder's own admin

5 critical gaps found in week 1. Pain validated.

Frame

Entity graph + classifier

13 tables, Claude classifier, GDrive adapter

Build

Working product

Web UI, gap engine, share links, 10K+ docs validated

Prove

Knowledge base + flows

Domain-specific guidance, life event flows, Totem integration

Built (working in production)

✓ Entity graph with 7 entity types + lifecycle states

✓ Claude-powered document classifier (20+ doc types)

✓ Google Drive ingestion adapter

✓ Progressive cascade classifier (L0–L3)

✓ Gap engine (lifecycle rules × states × docs)

✓ Web dashboard with 5 views

✓ Share links with field-level scoping

✓ Ingestion checkpointing for long scans

✓ Knowledge base architecture (domains + obligations)

✓ Guidance flow templates + step tracking

✓ 10,836 real documents validated

Planned (next)

☐ Multi-user auth + session management

☐ Totem credential delegation integration

☐ Additional storage adapters (Dropbox, S3, local)

☐ Scheduled / automatic ingestion

☐ Knowledge extraction from URL (scrape → Claude → seed)

☐ Zanzibar-style ReBAC authorization (SpiceDB/OpenFGA)

☐ B2B domain configuration (estate, RIA, law firm)

☐ Content-aware document matching (Layer C)

Studio Assessment

What PAM Proves

Proves About the Thesis

Metadata-only classification works at scale — 10,836 documents classified without reading contents

Lifecycle rules + entity states generate real, actionable gaps — 5 critical issues found in the founder's own records in week 1

Users choose legibility over magic — the triage workflow (approve/reject/edit) is preferred over auto-pilot

The "You Are an API" pattern works: extract data from black boxes (Google Drive), build own intelligence (gap engine), user controls it (entity graph)

Progressive disclosure of AI capability (L0–L3 cascade) matches the ambient → reflective layer model

What It Enables

PAM is Totem's first data source — the entity graph becomes the identity artifact that Totem's delegation engine shares across agents

Share links are the proto-TOTEM pattern — field-scoped, time-limited credential delegation proven at the product level before scaling to the protocol level

The knowledge base architecture (domains + obligations + flows) is domain-agnostic — the same engine works for estate planning, RIA compliance, and eldercare

The ingestion pipeline proves the adapter pattern — Google Drive today, any storage source tomorrow. The classifier doesn't care where the file came from

PAM validates the full B2B thesis: law firms, wealth managers, and CPAs all have the same problem at higher stakes and higher price points