# William Sheldon White, Forward Deployed Engineer

> I deploy agent systems into other people's live operations, usually on hardware they own, and I measure whether they actually work before I claim they do.

Tampa, FL, Eastern time. US citizen, clearance-eligible. Contact: Sheldonwhite888@gmail.com. GitHub: https://github.com/sheldon904. LinkedIn: https://www.linkedin.com/in/william-white-67a8ba206. Works at Bay West Labs: https://baywestlabs.com.

## Verified headline numbers
- 0% fabrication rate: Across 51 held-out decisions, graded against an expert-annotated set the agents could not query. Inter-rater kappa 0.95. (https://sheldondynamics.com/research/ontology-grounded-agents)
- $0.00 decision-path API spend: The whole pilot ran on Hermes-4-70B-FP8 under vLLM on one H100, network isolated. Total compute was about $8.50. (https://sheldondynamics.com/research/ontology-grounded-agents)
- 600/600 composes returned ok: Zero parse failures across two model families (321 on an 8B local tier, 279 on a 70B tier). (https://sheldondynamics.com/research/ontology-grounded-agents)
- 2 of 4 hypotheses refuted: Pre-registered before the run, published anyway when the data went against me. Reproduces bit for bit. (https://sheldondynamics.com/research/agent-memory-ablation)

## Pages
- [Home](https://sheldondynamics.com/)
- [Research](https://sheldondynamics.com/research): published studies and evaluation environments, including refuted hypotheses
- [Work](https://sheldondynamics.com/work): production case studies
- [Open Source](https://sheldondynamics.com/open-source): repos, grouped
- [Writing](https://sheldondynamics.com/blog)
- [About](https://sheldondynamics.com/about)
- [Resume (PDF)](https://sheldondynamics.com/william-white-resume.pdf)

## Research
### Augmented Operational Decisioning with Ontology-Grounded Local Agents (Published study, May 2026)
Page: https://sheldondynamics.com/research/ontology-grounded-agents
Finding: A federation of agents on a self-hosted 70B open-weight model produced operations-grade decisions on a contractor's real data with zero fabrications across 51 held-out decisions, and no frontier API anywhere in the decision path.
- Fabrication-guard trigger rate: 0% (0 of 51 held-out decisions)
- Strict capability (exact operator match): 66.7% (10 of 15), against a pre-registered 55% threshold
- Operations-defensible, independent judgment pass: 86.7% one-pass approve
- Substrate-consistent rationales: 100%
- Hallucinated entities: 0
- Inter-rater reproducibility: Cohen's kappa 0.95
- Compose reliability: 600 of 600 across two model families (321 on 8B, 279 on 70B)
- Decision-path API spend: $0.00
- Total compute including debugging: about $8.50 against a $26.66 budget
- Reported against the hypothesis: A divergence-from-control metric came back at 0% and was marked instrument-invalidated. The fixture's feedback hints had been authored to align with the control's default picks, so both arms reached the same answer for the right reason on each side. The metric was measuring the fixture, not the model. It was traced, documented, and given a surgical fix for the next run rather than quietly dropped.
- Reported against the hypothesis: An autonomous tool-call-rate hypothesis failed as anticipated, and the claim was reframed rather than defended. The system is prompt-grounded executable retrieval with a human approving each proposal, not an autonomous command loop.
- Reported against the hypothesis: This was a proof of concept on a single fixture, not a production benchmark. The capability number covers one task on one cohort and the sample is small at 15 eligible decisions.
- Read the study (PDF): https://sheldondynamics.com/little-bear-research-report.pdf
- Methodology and results: https://github.com/sheldon904/agent-eval-methodology
- The system it evaluates: https://sheldondynamics.com/work/little-bear-foundry

### Agent Memory Ablation (Published study, July 2026)
Page: https://sheldondynamics.com/research/agent-memory-ablation
Finding: Vector-free graph retrieval refused 100% of adversarial distractors. Hybrid retrieval, on the same corpus and the same harness, refused 10%. Two of four pre-registered hypotheses were refuted and published anyway.
- Known-item Recall@5, graph: 98.7%
- Known-item Recall@5, hybrid: 98.0%
- Known-item Recall@5, stateless RAG: 68.7%
- Refusal on adversarial distractors, graph: 100.0%
- Refusal on adversarial distractors, hybrid and RAG: 10.0%
- Pre-registered hypotheses refuted: 2 of 4
- Reported against the hypothesis: Two of the four pre-registered hypotheses were refuted. Both are in the results table with the rest.
- Reported against the hypothesis: The arm I expected to win did not. Adding a vector channel to the graph made distractor refusal ten times worse, which is the opposite of the intuition that more retrieval channels means better recall.
- Repo, paper, and reproduction command: https://github.com/sheldon904/agent-memory-ablation

### Hybrid Holographic Memory in a Production Personal Agent (Published study, July 2026)
Page: https://sheldondynamics.com/research/hybrid-holographic-memory
Finding: Graph, vector, and holographic memory in one SQLite store, characterized in vivo over 17 days: 1,976 recall events across 235 sessions at 37.4 ms median, with zero API calls on the hot path.
- Recall events observed: 1,976 across 235 sessions
- Full five-block recall pipeline: 37.4 ms median, 87.9 ms p95
- Trust-ledger changes recorded: 399
- Hot-path API calls: 0
- Store footprint: one 16.3 MB SQLite file on a 2 GB commodity host
- Read the study (PDF): https://sheldondynamics.com/hermes-hybrid-memory-study.pdf
- Repo: https://github.com/sheldon904/hermes-hybrid-memory
- How the analogy slot works: https://sheldondynamics.com/blog/hybrid-memory

### Claims Audit Agent: one task, three orchestration frameworks (Evaluation environment, July 2026)
Page: https://sheldondynamics.com/research/claims-audit-agent
Finding: Extended thinking cut LangGraph recall from 1.000 to 0.600 while raising Vercel AI SDK precision from 0.714 to 0.938. Same model, same tools, same frozen data, opposite behavior by orchestration.
- Deterministic engine, in CI on every push: precision, recall, and F1 of 1.000
- Fabrication rate, every arm: 0.000
- Citation validity, every arm: 1.000
- LangGraph recall, thinking off then on: 1.000 then 0.600
- Vercel AI SDK precision, thinking off then on: 0.714 then 0.938
- claude-agent-sdk on the holdout: 1.000 precision, recall, and F1, at about 18 times the cost per claim
- Reported against the hypothesis: The LangGraph arm's 0.000 fabrication rate is structural, not earned. An evidence-check node drops any citation it cannot verify, so the zero holds regardless of what the model proposes. The two autonomous arms earn their zero from the model plus a strict schema, which is a weaker guarantee, and the writeup says so.
- Reported against the hypothesis: The claude-agent-sdk arm is demonstrated on the holdout, not run at full scale. It spawns a fresh CLI subprocess per claim, which is flaky against a third-party endpoint and roughly 15 times slower. The trade is cost, latency, and stability, not correctness.
- Live results: https://claims-audit-agent.vercel.app
- Repo: https://github.com/sheldon904/claims-audit-agent

### Confounded churn: what adoption actually causes (Evaluation environment, July 2026)
Page: https://sheldondynamics.com/research/cs-intel
Finding: The naive read says high-adoption accounts churn 30.4 percentage points less. Adjusting for account size puts the true effect at 11.7 points. The correction removes about 88% of the confounding bias, and the generator knows the right answer, so the correction is checkable.
- Naive (confounded) effect of adoption on churn: 30.4 pp lower churn
- True effect, known from the generator: 11.7 pp
- Confounding bias removed by adjustment: about 88%
- XGBoost on holdout: 0.806 ROC-AUC, 0.624 PR-AUC
- LLM intent labeling against the gold set: Cohen's kappa 0.80
- Churn AUC lift from intent features: 0.735 to 0.814
- Cost per account scored: about $0.0035
- Repo: https://github.com/sheldon904/cs-intel

## Production work
### Little Bear Foundry: Nine role-specialized agents deployed beside a customer's live operation, on their hardware
Production. Architect and sole engineer (2026). Case study: https://sheldondynamics.com/work/little-bear-foundry
Constraint that shaped it: The operational data could not leave the building, and a 7B model authored valid triples at roughly a 0% exact-match rate. Both facts are load-bearing. The first ruled out a frontier API in the decision path. The second ruled out letting agents write to the substrate at all, which is why the graph is a read-only derived cache with a projector as its sole writer.
- Outcome: 0% fabrication across 51 held-out decisions, graded against an expert-annotated set the agents could not query. Inter-rater kappa 0.95.
- Outcome: 66.7% strict-match and 86.7% operations-defensible foreman picks on 15 eligible cases against the holdout. The pre-registered threshold was 55%.
- Outcome: 100% compose reliability with zero parse failures across 600 runs spanning two model families (321 on an 8B local tier, 279 on a 70B tier).
- Outcome: Roughly $8.50 of total compute against a $26.66 budget, and $0.00 of API spend in the decision path.
- Outcome: A CI regression gate fails the build on a 10-point tool-breadth drop or a 10% p95 latency regression, so capability cannot rot quietly between changes.
Stack: Multi-agent, MCP, Hermes-4-70B-FP8 / vLLM, RDF / SPARQL, TrustGraph / Oxigraph, DoWhy / PyMC / EconML, PostgreSQL, TypeScript.

### OTTER: The operations platform a 30-employee Florida contractor runs its business on, daily
Production, in daily use. Architect and lead developer (2025 to present). Case study: https://sheldondynamics.com/work/otter
Constraint that shaped it: Invoicing rules were not uniform. Each client and each operating division wanted a different document, in a different format, built from the same field data. That is why the document pipeline is a first-class subsystem rather than a report button, and why the permission model goes down to per-user overrides instead of stopping at roles.
- Outcome: Invoice cycle went from multiple days of manual work to same-day.
- Outcome: Foreman administrative time down roughly 30%.
- Outcome: In daily production use at a 30-employee contractor across multiple operating divisions.
Stack: Next.js, TypeScript, PostgreSQL, Prisma, Neon, Vercel, RBAC, PDF / XLSX / DOCX.

### Always-on agent runtime: Roughly 10 scheduled agent workflows running unattended for weeks, with a human approving every state change
Production. Architect and sole engineer (2025 to present). Case study: https://sheldondynamics.com/work/always-on-agent-runtime
Constraint that shaped it: An unattended agent with write access to production is a liability, not a feature. Everything here is built around that: a default-deny trust ladder, a human approval step on every state-changing action, and no auto-merge anywhere in the pipeline.
- Outcome: About 10 hours a week returned, with a human approving every state-changing action.
- Outcome: Found and remediated real defects in my own production stack: hardcoded secrets, a committed HMAC key, and an unauthenticated debug endpoint. I led the rotation.
- Outcome: Migrated to k3s with the trust boundaries moved into NetworkPolicy. See backbone-on-k8s for the verification record.
Stack: TypeScript, MCP, Docker, systemd, Tailscale, OpenRouter, Telegram, HMAC.

### Shafer Law Payments: Card and ACH payments for a law firm, under PCI SAQ-A
Production. Architect and sole engineer (2026). Case study: https://sheldondynamics.com/work/shafer-law-payments
Constraint that shaped it: A replayed Stripe webhook that double-applies a payment is not a bug you apologize for at a law firm, and the audit trail has to survive bar-association review. That is why money is integer cents, invoice numbering is atomic, deduplication is two-layer, and the log is append-only.
- Outcome: Handling real client payments in production.
- Outcome: No double-charges, deterministic reconciliation, and a full audit trail by construction rather than by convention.
Stack: Next.js, TypeScript, Stripe, Prisma, PostgreSQL, Clerk, Vercel.

### Airport: An AI transaction coordinator for Florida real-estate deals
Public repo. Engineer (2025). Case study: https://sheldondynamics.com/work/airport
Constraint that shaped it: Florida statutory deadlines are counted in business days from a triggering event, and a miscount has legal consequences. The deadline math is therefore its own module with its own tests, not an inline date calculation.
- Outcome: Public repo, 47 tests passing.
Stack: React, TypeScript, Hono, FastAPI, PostgreSQL, pgvector, Claude API, Redis.

### WINRATE: An autonomous RFP-response platform with 5-agent orchestration
Internal R&D. Engineer (2025). Case study: https://sheldondynamics.com/work/winrate
Constraint that shaped it: One missed compliance requirement disqualifies an entire bid, so the compliance agent is a gate rather than a reviewer, and a human signs off at each quality checkpoint.
- Outcome: Drafts compliance-checked RFP responses with a human approving at every gate.
Stack: Multi-agent, pgvector, Hybrid search, SSE, TypeScript.

## Open source
### Evaluation environments
- claims-audit-agent (https://github.com/sheldon904/claims-audit-agent): A medical-claims auditing task environment where the labels are verified by an independent engine before any record reaches disk, and the same agent is scored across three orchestration frameworks. Why: I did not trust labeled data I had not generated, so I built the scorer first and made the agents swappable arms behind it.
  Measured: Deterministic rule engine pinned at F1 1.000 in CI. Extended thinking cut LangGraph recall from 1.000 to 0.600 and raised Vercel precision from 0.714 to 0.938.
  Live demo: https://claims-audit-agent.vercel.app
- agent-memory-ablation (https://github.com/sheldon904/agent-memory-ablation): A controlled ablation of stateless RAG, knowledge graph, and hybrid retrieval on one frozen corpus behind one shared typed interface. Why: Every retrieval comparison I could find changed the corpus along with the architecture, which makes the result unreadable.
  Measured: Graph-only retrieval hit 98.7% Recall@5 and refused 100% of adversarial distractors where hybrid refused 10%. Two of four pre-registered hypotheses refuted.
- agent-eval-methodology (https://github.com/sheldon904/agent-eval-methodology): The evaluation harness and evidence discipline behind a 14-run pilot of a multi-agent system on a contractor's live operations data. Why: The methodology is the part worth publishing. The capability number means nothing without the holdout design that produced it.
  Measured: Two-database holdout, pre-registered thresholds, Cohen's kappa 0.95, 0 fabrications across 51 held-out decisions, one metric marked instrument-invalidated.
- cs-intel (https://github.com/sheldon904/cs-intel): A customer-success pipeline combining classical ML, LLM labeling, causal inference, and an approval-gated agent, running fully offline on synthetic data with a known churn process. Why: A confounder planted on purpose is the only way to check whether your causal correction actually corrects anything.
  Measured: DoWhy adjustment moves adoption's effect from a naive 30.4 pp to the true 11.7 pp, removing about 88% of the confounding bias. 0.806 ROC-AUC, 55 pytest tests.

### MCP servers
- sparql-mcp (https://github.com/sheldon904/sparql-mcp): A SPARQL 1.1 MCP server exposing four read tools to agents with no UPDATE surface at all. INSERT, DELETE, DROP, CLEAR, CREATE GRAPH, and LOAD are rejected before they reach the store. Why: Prompting a model not to write to your knowledge graph is a request. Removing the verb is a guarantee. Host-guarded to localhost, MIT licensed.
- causal-evidence-mcp (https://github.com/sheldon904/causal-evidence-mcp): Six causal-inference tools over two surfaces (a FastAPI HTTP API and a FastMCP SSE server), wrapping DoWhy, PyMC NUTS with R-hat and ESS diagnostics, EconML CausalForestDML, and causal-learn's PC algorithm behind one uniform envelope. Why: An agent handed a causal estimate from a cohort of four will use it. This returns a structured "insufficient" below a minimum cohort size instead of a number nobody should trust. Every endpoint but one runs fully offline.
- hermes-hybrid-memory (https://github.com/sheldon904/hermes-hybrid-memory): Graph, vector, and holographic memory for agents in one SQLite store, with a Hofstadter-inspired analogy slot, emergent chunking, and usage-driven forgetting. Why: Most agent memory retrieves what is similar. I wanted one that also retrieves what is analogous: structurally alike but different on the surface.
  Measured: 17-day in-vivo characterization: 1,976 recall events across 235 sessions at 37.4 ms median, zero hot-path API calls.

### Infrastructure
- backbone-on-k8s (https://github.com/sheldon904/backbone-on-k8s): Migration of my always-on agent runtime from systemd on a droplet to k3s: Cilium CNI, sealed-secrets with no cloud-provider dependency, Keycloak plus oauth2-proxy for SSO, Helm charts, and Grafana. Why: MCP servers were forked child processes, so the trust boundaries lived implicitly in a process tree. Converting them to network-accessible HTTP services lets NetworkPolicy enforce those boundaries in YAML instead.
  Measured: VALIDATION.md separates what is verified locally, in CI, and on a live cluster. Recall 3.27 ms with zero probe failures, a 22 MB WAL-mode database backed up online in 0.18 s, NetworkPolicy enforcement confirmed under Cilium, 21 of 21 parity constraints, and $0.00767 per task across 1,111 sessions.
- agent-fleet-on-eks (https://github.com/sheldon904/agent-fleet-on-eks): Terraform, Helm, and GitHub Actions shipping agent services to Amazon EKS: test, build, push to ECR, approval gate, Helm upgrade. Why: Handing a system to a platform team means no long-lived credentials anywhere in CI. GitHub OIDC federation to AWS and IRSA in-cluster, with GitHub Environments and required reviewers gating production.
  Measured: End-to-end trust flow proven locally with real sockets and HMAC verification. VALIDATION.md marks exactly which rows still need a live AWS account.

### Systems
- vigil (https://github.com/sheldon904/vigil): A security telemetry system in three services: HMAC-validating ingest to Kafka, in-memory windowed rule detection, and an alert API persisting to PostgreSQL and indexing into Elasticsearch with Kibana dashboards. Why: Detection thresholds belong in configuration, not in code. All of them live in application.yml.
  Measured: Brute force at 5+ auth failures from one source in 60 s (HIGH), port scan at 15+ distinct ports in 30 s (MEDIUM), impossible travel across regions within 5 minutes (HIGH). Testcontainers integration tests against real Kafka and Postgres.
- Airport (https://github.com/sheldon904/Airport): An AI real-estate transaction coordinator: six agents plus Claude Vision document extraction over a Florida compliance engine. Why: Florida statutory deadlines run in business days from a triggering event, and a miscount has legal consequences, so the deadline math is its own tested module.
  Measured: 15+ statutory requirements covered, 47 tests passing.