# Vision & Plan: FOSS PostgreSQL + Apache AGE Platform

## What This Document Is

This is the master reference for building a FOSS data integration platform anchored on Apache AGE (PostgreSQL graph extension). It captures strategic context, technical architecture, and phased execution plans. It is designed to be consumed by both humans and Claude Code as working context.

**Owner:** Greg
**Status:** Active development
**Last updated:** 2026-02-25

---

## Current Status

**As of 2026-02-25:** Phase 0 (Foundation). Vision and plan document drafted. Infrastructure setup, AGE dev environment, and contributor onboarding are the immediate next steps. IP addendum status and Forgejo/Woodpecker CI provisioning are the current blockers.

*Update this section as milestones are completed.*

---

## 1. The Big Picture

### Vision

Build the **Red Hat of graph databases** — an open-source-first company that:

1. Contributes meaningfully to Apache AGE and the PostgreSQL ecosystem
2. Ships FOSS SDKs, tooling, and integration patterns that make AGE production-ready
3. Monetizes via certified distributions, managed services, consulting, and premium features
4. Serves regulated industries (DoD, utilities, legal) where compliance + graph + AI intersect

### Why AGE

- AGE is a PostgreSQL extension, not a separate database — one engine for relational, graph, vector (pgvector), time-series (TimescaleDB), and geospatial (PostGIS)
- The AGE project is understaffed and slow-moving relative to its potential
- LLM-accelerated contribution (Claude Code) can disproportionately increase output
- No one is doing AGE + pgvector integration well — that's a wide-open differentiator
- PostgreSQL already has DoD STIGs, FedRAMP precedent, and massive enterprise adoption

### Competitive Positioning

| Capability | AGE (this platform) | Neo4j | Kùzu | NebulaGraph | pgvector-only |
|---|---|---|---|---|---|
| Graph queries (Cypher) | Yes (extension) | Yes (native) | Yes (embedded) | Yes (nGQL) | No |
| Vector search | Yes (pgvector) | Yes (add-on) | No | No | Yes |
| Graph + vector hybrid | **Planned — key differentiator** | Bolt-on, limited | No | No | No |
| Relational joins | Native (it's Postgres) | No | Limited | No | Native |
| Time-series | Yes (TimescaleDB) | No | No | No | Yes (TimescaleDB) |
| Geospatial | Yes (PostGIS) | Limited | No | No | Yes (PostGIS) |
| JSONB / document | Native | No | No | No | Native |
| Compliance posture | PG STIGs, FedRAMP precedent | Limited | None | None | PG STIGs |
| Operational burden | One engine (PostgreSQL) | Separate DB | Embedded only | Separate cluster | One engine |
| License | Apache 2.0 | GPL (Community) / Commercial | MIT | Apache 2.0 | PostgreSQL |

**The core argument:** Neo4j is the incumbent but requires a separate database engine. pgvector-only solutions lack graph structure. AGE is the only path to graph + vector + relational + time-series + geospatial in a single PostgreSQL instance, with enterprise compliance posture inherited from PostgreSQL.

### Business Model

```
FOSS Core (Apache Licensed)
├── Apache AGE contributions (Cypher completeness, performance, PG version support)
├── AGE + pgvector integration layer
├── Python/JS/Rust SDKs for graph + vector + time-series operations
├── GNN pattern library (PyTorch Geometric on AGE data)
├── Benchmark suites and migration tools
└── Documentation, examples, tutorials

Commercial Layer (Post-Employment)
├── Certified Distribution — hardened, compliance-ready AGE bundles
├── AGE Unity — data governance & catalog (Databricks Unity Catalog equivalent)
├── Managed Platform — SaaS/PaaS offering
├── Industry Compliance Packs — CMMC, NERC CIP, SOC2
├── Professional Services — implementation, migration, training
└── Premium Support with SLAs
```

### Three Product Lines That Share This Foundation

1. **The Platform** — FOSS data integration platform for enterprise/DoD
2. **LegalFlow** — AI-powered legal tech (NYSCEF automation, case management) for small law firms
3. **ROI/Value Engineering Tools** — Quanta/Valuescaler lineage, financial modeling on graph data

All three consume the same AGE + PostgreSQL foundation. The platform is the base layer; LegalFlow and the ROI tools are vertical applications built on it.

---

## 2. Technical Architecture

### The Unified PostgreSQL Stack

```
┌──────────────────────────────────────────────────────────┐
│                     APPLICATION LAYER                     │
│  LegalFlow │ ROI Tools (Quanta) │ Compliance Dashboards  │
├──────────────────────────────────────────────────────────┤
│                        SDK LAYER                         │
│  Python SDK │ JS/TS SDK │ Rust SDK (future)              │
│  Graph ops │ Vector ops │ Time-series │ Financial │ GNN  │
├──────────────────────────────────────────────────────────┤
│                    GOVERNANCE LAYER                       │
│  AGE Unity (catalog, RBAC, lineage, audit)               │
├──────────────────────────────────────────────────────────┤
│                   STORAGE ENGINE LAYER                    │
│  Apache AGE    │ pgvector     │ TimescaleDB │ PostGIS    │
│  (graphs)      │ (embeddings) │ (sensors)   │ (geo)      │
│                │              │             │            │
│  ──────────── PostgreSQL 17/18 ───────────────────────   │
│  JSONB (docs)  │ Star Schema  │ FDW (Iceberg/Delta)     │
├──────────────────────────────────────────────────────────┤
│                     INFRASTRUCTURE                        │
│  Forgejo + Woodpecker CI │ Docker/K8s │ restic backups   │
│  Self-hosted │ Personal hardware only                    │
└──────────────────────────────────────────────────────────┘
```

### Storage Engine Boundaries

**Apache AGE (graph)** — Structural/relational data. Organizations, people, assets, dependencies, compliance controls, case relationships, technology stacks. The "who connects to what and why" questions.

**PostgreSQL star schema (relational)** — Financial measures against dimensional structures. Cost allocations, spend actuals, budgets, forecasts, revenue, benchmarks. The "how much, where, when" questions. TBM cost models live here.

**pgvector** — Embeddings for semantic search, document similarity, RAG retrieval. Legal document embeddings, configuration embeddings for similarity analysis.

**TimescaleDB** — Time-series sensor data, financial time-series, audit event streams.

**JSONB** — Flexible schema for discovery data, API responses, configuration snapshots, strawman data that hasn't been structured yet.

### Domain Architecture (Two Clusters)

**Cluster 1: Analytical/Intelligence** (reference + instance pattern)
- Reference layer: industry frameworks, standard taxonomies, compliance templates
- Instance layer: customer-specific instantiation of reference data
- Operational layer: live telemetry, discovered state, real-time measures

**Cluster 2: GTM Operations**
- Pipeline, engagement tracking, delivery management
- Connects to Cluster 1 at the customer engagement point

**Key patterns:**
- "Strawman to real" data progression — start with estimates, refine with actuals
- Reference vs instance separation — one compliance framework template, many customer instantiations
- Graph for structure, star schema for measures — never mix these
- Causal model: Problem → Metric → Solution (the thing that makes ROI tools work)

### The AGE + pgvector Differentiator

This is the killer feature no one else is building well.

**Proposed API** — these functions (`vector_similarity`, `semantic_neighbors`) do not exist yet in AGE or pgvector. Building them is a core deliverable of this project:

```sql
-- PROPOSED: Graph traversal constrained by vector similarity
SELECT * FROM cypher('legal_graph', $$
    MATCH (c:Case)-[:CITES]->(p:Precedent)
    WHERE vector_similarity(p.embedding, $query_embedding) > 0.7
    AND c.court = 'NYSC'
    RETURN p
$$) as (precedent agtype);

-- PROPOSED: Semantic neighbors within graph neighborhood
MATCH (a:Asset)-[:CONNECTED*1..3]-(m:Asset)
WHERE semantic_neighbors(m, $query_embedding, top_k => 10)
RETURN m
```

**What this enables:**
- Legal: "Find precedents cited by similar cases in this court" (graph + vector)
- DoD: "Find assets with similar configs within 3 hops of this compromised node" (graph + vector)
- Compliance: "Which controls are most similar to this finding, within this regulatory boundary" (graph + vector)

### GNN Layer (PyTorch Geometric)

GNNs learn patterns in graph structure that queries and LLMs cannot detect:

- **ROI prediction**: Train on graph of customer accounts, tech stacks, migration paths → predict risk-adjusted outcomes
- **Compliance cascade**: Train on asset/dependency/control graphs → predict which changes cascade into violations
- **Network security**: Train on network topology → anomaly detection, drift detection
- **Legal**: Link prediction over case/statute/judge/outcome graphs → "what precedents are most persuasive for this judge"

GNNs are NOT a replacement for LLMs. LLMs handle intent parsing, reasoning, document generation. GNNs handle structural pattern recognition on graph data. Both feed the platform.

### Testing & QA Strategy

**AGE contributions:** Follow upstream's existing `regress/sql/` test patterns. All PRs must pass the full AGE regression suite in Docker before submission. Add new regression tests for every feature or fix.

**Python SDK:** pytest with type hints enforced via mypy. Target 90%+ coverage on core modules. Integration tests run against a Docker AGE instance (PG18 + AGE + pgvector). Use `testcontainers-python` or Docker Compose for reproducible test environments.

**AGE Unity (governance layer):** Integration tests covering RBAC enforcement, lineage tracking, and audit logging. Contract tests between SDK and Unity API surfaces.

**Benchmarks:** Automated regression — every PR runs the benchmark suite and flags performance regressions > 10%. Results stored in JSON for trend tracking.

**CI pipeline (Woodpecker):** Lint (ruff/black) → type check (mypy) → unit tests → integration tests (Docker) → benchmark regression. All green before merge.

---

## 3. Infrastructure

### Dev Environment

- **Primary workstation**: i9 / 64GB RAM / RTX 4090
- **Source control**: Forgejo (self-hosted, Go, community-governed)
- **CI/CD**: Woodpecker CI (container-native, pairs with Forgejo)
- **Container registry**: Harbor (CNCF project)
- **Backups**: restic → Google Drive (2TB plan) via rclone
- **All work on personal hardware, personal accounts, outside work hours**

### Repository Structure (Target)

Working name: **piggie** (see Open Question #4 on naming).

```
piggie/
├── CLAUDE.md                    # Claude Code context (points here)
├── VISION-AND-PLAN.md           # This document
├── docs/
│   ├── DOMAIN-ARCHITECTURE.md   # Domain model spec
│   ├── adr/                     # Architecture Decision Records
│   └── skills/                  # Claude Code skill files
├── age-contrib/                 # AGE patches, PRs, benchmarks
│   ├── cypher-gaps/             # Missing Cypher functions
│   ├── pgvector-integration/    # AGE + pgvector work
│   ├── benchmarks/              # Performance benchmark suite
│   └── patches/                 # Submitted/pending PRs
├── sdk/
│   ├── python/                  # Python SDK (priority)
│   │   ├── age_graph/           # Graph operations
│   │   ├── age_vector/          # pgvector operations
│   │   ├── age_timeseries/      # TimescaleDB operations
│   │   ├── age_gnn/             # GNN pattern library
│   │   └── age_financial/       # Quanta financial models
│   ├── js/                      # JavaScript/TypeScript SDK
│   └── rust/                    # Rust SDK (future)
├── unity/                       # AGE Unity (governance/catalog)
├── legalflow/                   # Legal tech application
├── quanta/                      # ROI/value engineering tools
├── infra/
│   ├── docker/                  # Docker compose files
│   ├── k8s/                     # Kubernetes manifests (future)
│   └── ci/                      # Woodpecker pipeline configs
└── benchmarks/
    ├── datasets/                # Synthetic + real-world graphs
    ├── queries/                 # Cypher, vector, hybrid queries
    ├── runners/                 # AGE, Neo4j, baseline runners
    ├── security/                # Security-specific benchmarks
    └── reports/                 # Automated report generation
```

---

## 4. Phased Execution Plan

### Employment Constraint Context

Greg is currently employed. An IP addendum is in progress (lawyer engaged) to clarify that personal projects on personal time/hardware are Greg's IP. Until that addendum is signed, activity must be clearly positioned as open-source contribution, not commercial product development.

**Tier 1 — Safe now (post-addendum signing):**
- Apache AGE open source contributions (Apache license)
- FOSS SDK development (public repo, Apache license)
- Benchmarks, blog posts, conference talks
- Technical research and documentation

**Tier 2 — Gray zone:**
- ROI tools (signals commercial intent) — BUT these are prior inventions predating employment, unmodified since hire. Strong legal position, but maintain "no modifications during employment" discipline.

**Tier 3 — Post-employment only:**
- Commercial packaging, pricing, customer engagement
- Certified distributions, managed services
- Direct sales or DoD contracting

### Phase 0: Foundation (Now → Addendum Signed)

**Goal:** Establish AGE contributor identity, set up infrastructure, learn the codebase.

```
TASKS:
□ Read AGE GitHub issues, PRs, contributor guidelines
□ Identify low-hanging fruit contributions
□ Set up Forgejo + Woodpecker CI on personal infrastructure
□ Set up Docker-based AGE dev environment (PG17/18 + AGE 1.7.0)
□ Review AGE Cypher implementation vs openCypher spec — document gaps
□ Install pgvector alongside AGE — test basic hybrid queries
□ Get IP addendum signed (lawyer review → submit → negotiate)
□ Create CLAUDE.md for Claude Code with pointers to this doc

DELIVERABLES:
- Running AGE dev environment
- Gap analysis document (Cypher completeness)
- Initial pgvector + AGE hybrid query experiments
- Signed IP addendum
```

### Phase 1: AGE Contributor Credibility (Months 1-3)

**Goal:** Ship real contributions to AGE, establish public presence.

```
MONTH 1: Performance & Stability
□ Benchmark AGE query performance (traversal depth, graph size, write throughput)
□ Identify bottlenecks, submit issues with data
□ Pick 1-2 small performance improvements, submit PRs
□ Blog post: "AGE Performance Analysis on PG18"
□ Set up automated benchmark framework

MONTH 2: Cypher Completeness
□ Systematically fill Cypher gaps (missing functions, clauses)
□ Generate test cases from openCypher spec, run against AGE
□ Submit PRs for missing features (start with trivial ports)
□ Blog post: "Cypher Feature Parity — Where AGE Stands"

MONTH 3: pgvector Integration Prototype
□ Build proof-of-concept: AGE + pgvector hybrid queries
□ Test graph-constrained vector search patterns
□ Benchmark hybrid query performance
□ Blog post: "Graph + Vector Search with AGE and pgvector"
□ Public GitHub repo with examples

DELIVERABLES:
- 5-10 AGE PRs submitted
- 3+ blog posts published
- Reproducible benchmark suite
- Public repo with AGE + pgvector examples
- Active presence in AGE community (mailing list, Discord)

CLAUDE CODE ACCELERATION:
- Use Claude Code for implementing missing Cypher functions
  (bounded, well-specified tasks with clear test patterns)
- Use Claude Code for generating comprehensive test suites
- Use Claude Code for benchmark framework scaffolding
- Use Claude Code for blog post drafting from technical findings
```

### Phase 2: SDK & Developer Experience (Months 4-6)

**Goal:** Build the Python SDK that makes AGE usable for real applications.

```
MONTH 4: Python SDK — Graph Operations
□ Clean API for Cypher queries via AGE
□ Graph traversal convenience functions
□ Batch operations, connection pooling
□ Example notebooks (generic use cases)
□ PyPI package: age-toolkit (or similar)

MONTH 5: Python SDK — Vector + Hybrid Operations
□ pgvector integration layer
□ Graph-constrained vector search API
□ Embedding management utilities
□ Hybrid query builder (Cypher + vector in one call)

MONTH 6: Python SDK — GNN Patterns
□ PyTorch Geometric integration
□ Graph embedding utilities (Node2Vec, DeepWalk)
□ GNN training recipes for common patterns
□ Example: anomaly detection on graph data
□ Example: link prediction

DELIVERABLES:
- Published Python SDK on PyPI
- Comprehensive documentation + tutorials
- 5+ example notebooks
- Neo4j → AGE migration guide
- Growing GitHub stars / community adoption

CLAUDE CODE ACCELERATION:
- SDK scaffolding and boilerplate
- Test generation for SDK functions
- Documentation generation from code
- Example notebook creation
- Migration guide content
```

### Phase 3: Governance & Catalog (Months 7-12)

**Goal:** Build AGE Unity — the governance layer that makes this enterprise-ready.

```
AGE Unity Core Features:
□ Three-level namespace (catalog.schema.table/graph)
□ Fine-grained access control (row/column/graph-level)
□ Data lineage tracking across transformations
□ Centralized metadata (schemas, tags, ownership)
□ Audit logging (who accessed what, when)
□ Cross-workspace governance

Additional Platform Work:
□ TimescaleDB integration in SDK
□ PostGIS integration in SDK  
□ Lakehouse integration (Iceberg/Delta via FDW)
□ Apache Airflow + dbt integrations
□ Compliance pack foundations (CMMC, NERC CIP, SOC2)

Security Benchmarks:
□ Graph-based security analysis patterns
□ Network topology anomaly detection
□ Compliance posture scoring
□ Penetration test result graph modeling

DELIVERABLES:
- AGE Unity MVP in production
- Complete SDK covering graph + vector + time-series + governance
- Industry-specific examples (defense, utilities, legal)
- Published benchmark comparisons (AGE vs Neo4j, pgvector vs Pinecone)
```

### Phase 4: Commercial Launch (Post-Employment)

**Goal:** Package and sell.

```
Product Tiers:
1. Community Edition (Free, FOSS)
   - Core platform + basic monitoring + community support

2. Enterprise Edition ($100K-500K/year)
   - Unity Catalog + advanced monitoring + compliance packs
   - STIG-hardened configs + premium support

3. Federal Edition ($200K-2M/year)
   - FedRAMP package + IL4/5/6 deployment
   - Continuous compliance monitoring + dedicated CSM

Parallel: LegalFlow Launch
- NYSCEF automation (registration, filing, status, retrieval)
- RAG + agentic AI on frontier models (not fine-tuned)
- Knowledge graph over cases, statutes, judges, outcomes
- Target: small NY law firms

Parallel: ROI Tools (Quanta Revival)
- Prior inventions, unmodified — strong IP position
- Financial modeling on graph data
- TCO/ROI analysis with graph-based what-if scenarios
```

---

## 5. Claude Code Integration Strategy

### Why This Works

AGE contributions are ideal for LLM-accelerated development because:

1. **Bounded problem space** — database extensions have well-defined interfaces, test suites, specs
2. **Clear documentation** — PostgreSQL internals, openCypher spec, existing AGE codebase
3. **Measurable outcomes** — query performance, feature completeness, test coverage
4. **Structured contribution process** — Apache governance, clear PR workflow

### Claude Code Workflow

```
1. CONTEXT LOADING
   - Claude Code reads CLAUDE.md → points to this document
   - Claude Code reads DOMAIN-ARCHITECTURE.md for data model context
   - Claude Code reads relevant AGE source files

2. TASK SPECIFICATION
   - Describe the task with clear requirements and acceptance criteria
   - Reference openCypher spec for Cypher implementation tasks
   - Reference existing AGE patterns for consistency
   - Provide test examples from AGE's existing test suite

3. IMPLEMENTATION
   - Claude Code generates implementation following AGE conventions
   - Claude Code generates comprehensive tests
   - Claude Code runs tests locally in Docker environment

4. REVIEW & SUBMIT
   - Human review of generated code
   - Run full AGE test suite
   - Submit PR to apache/age with clear description
```

### Example Claude Code Tasks

```bash
# Implement missing Cypher function
claude "Implement the Cypher reverse() function for AGE following
the pattern in existing string functions in src/backend/utils/adt/agtype_util.c.
Include unit tests matching the style in regress/sql/cypher_funcs.sql.
Benchmark against PostgreSQL's native string_reverse()."

# Generate test suite
claude "Generate comprehensive test cases for AGE's shortest path
algorithm covering: weighted/unweighted, directed/undirected,
negative weights, cycles, disconnected graphs. Follow existing
patterns in regress/sql/."

# Benchmark framework
claude "Build a Python benchmark framework that:
1. Creates parameterized test graphs (1K to 1M nodes)
2. Runs standard Cypher queries against AGE
3. Measures latency percentiles and throughput
4. Generates markdown report with charts
Use Docker for AGE instances. Store results in JSON."

# SDK development
claude "Create a Python SDK module for AGE graph operations with:
- Connection pooling via psycopg
- Cypher query builder with parameterized queries
- Graph traversal convenience methods
- Batch insert/update operations
- Type-safe result parsing
Follow the patterns in the existing pgvector Python client."

# pgvector integration
claude "Write an AGE extension module that enables hybrid queries:
graph traversal filtered by vector similarity. Test with a
1000-node graph where each node has a 384-dim embedding.
Measure query latency vs separate AGE + pgvector queries."
```

### CLAUDE.md Template (for repo root)

```markdown
# CLAUDE.md

## Project Context
See VISION-AND-PLAN.md for full strategic context, architecture, and phased plan.
See docs/DOMAIN-ARCHITECTURE.md for data model specification.

## Current Phase
Phase 1: AGE Contributor Credibility (Months 1-3)
Focus: Performance benchmarks, Cypher completeness, pgvector integration prototype

## Development Environment
- PostgreSQL 18 + Apache AGE 1.7.0 (Docker)
- pgvector installed alongside AGE
- Python 3.12+ for SDK work
- PyTorch + PyTorch Geometric for GNN work

## Conventions
- All AGE contributions follow apache/age contributor guidelines
- Python code: black formatter, pytest, type hints
- All work Apache 2.0 licensed
- Commits outside work hours only, personal hardware only

## Key Files
- VISION-AND-PLAN.md — master strategy and execution plan
- docs/DOMAIN-ARCHITECTURE.md — domain model (graph vs star schema boundaries)
- benchmarks/ — performance benchmark framework
- sdk/python/ — Python SDK source
- age-contrib/ — AGE patches and PRs in progress
```

---

## 6. Success Metrics

### Phase 1 (3 months)
- [ ] 10+ AGE PRs submitted (within your control)
- [ ] 5+ AGE PRs merged (dependent on upstream review cycles)
- [ ] Benchmark suite running with reproducible results
- [ ] 3+ published blog posts
- [ ] AGE + pgvector hybrid queries working in prototype
- [ ] Active in AGE community (recognized contributor)

### Phase 2 (6 months)
- [ ] Python SDK on PyPI with 100+ downloads/month
- [ ] 10+ GitHub stars on SDK repo
- [ ] Neo4j migration guide published
- [ ] Speaking proposal submitted to a PostgreSQL/graph conference
- [ ] GNN pattern library with 3+ working examples

### Phase 3 (12 months)
- [ ] AGE Unity MVP functional
- [ ] Complete SDK (graph + vector + time-series + governance)
- [ ] Published benchmark: AGE vs Neo4j (competitive results)
- [ ] 3+ organizations using SDK in production or evaluation
- [ ] SOC 2 compliance documentation started

### Phase 4 (18+ months)
- [ ] First paying customer
- [ ] $100K+ ARR
- [ ] LegalFlow live with NYSCEF automation
- [ ] 15+ AGE contributions merged
- [ ] Team of 2-3 (including Greg)

---

## 7. Risk Register

| Risk | Likelihood | Impact | Mitigation |
|------|-----------|--------|------------|
| Employer claims IP | Medium | Critical | IP addendum + lawyer + own time/hardware discipline |
| AGE project dies or forks | Low | High | PostgreSQL itself isn't going anywhere; fork if needed |
| Neo4j competes on price | Medium | Medium | Differentiate on pgvector integration, unified Postgres stack |
| Can't get traction as contributor | Low | Medium | Start with documentation/tests — low bar, high value |
| Claude Code produces bad AGE patches | Medium | Low | Human review all PRs; run full test suite before submission |
| Employment discovered before addendum | Low | Critical | Maintain strict separation; no commits during work hours |
| Market doesn't value FOSS graph DB | Medium | High | LegalFlow and ROI tools provide revenue independent of platform sales |

---

## 8. Open Questions (Unresolved)

These are things we discussed but didn't finalize. They need prototyping or decisions:

1. **Caching strategy** — Materialized views? Application-level cache? Deferred until query patterns emerge.
2. **Inheritance model** — Fork-and-track-divergence vs overlay/layering vs full materialization at onboard time. Needs prototyping.
3. **Equivalence mapping representation** — Schema design for mutation mappings in AGE. Needs prototyping.
4. **Naming** — "piggie" is the working name for the platform repo. "Quanta" and "Valuescaler" are legacy names from the MFC context. Decide whether "piggie" becomes the public-facing name or a code name to be replaced before launch.
5. **LegalFlow architecture** — Persistent browser session (Playwright) vs API integration for NYSCEF. mitmproxy analysis of NYSCEF traffic should inform this.
6. **GNN training infrastructure** — RTX 4090 sufficient for initial work, but production GNN training at scale may need cloud GPU.

---

## Appendix A: Key Conversation References

These Claude.ai conversations contain detailed context on specific topics:

- **AGE acceleration with Claude Code**: Strategy for LLM-accelerated OSS contribution
- **Employment IP / addendum**: Legal strategy, safe activities, tier system
- **Domain architecture**: Two-cluster model, reference vs instance, graph vs star schema
- **PyTorch vs LLMs**: Where GNNs add value vs frontier model RAG
- **LegalFlow / NYSCEF**: Court filing automation, Cloudflare bypass, architecture
- **FOSS infrastructure**: Forgejo + Woodpecker CI + Harbor stack
- **Fine-tuning vs RAG**: Why RAG + agentic wins for LegalFlow

---

*This document is the source of truth. Update it as decisions are made and phases complete. Claude Code should reference this for strategic context on any task.*
