Adam Reed

Senior Software Engineer · Distributed Systems (.NET)

18 years building software. The last nine as founder and hands-on CTO.

This page runs newest to oldest. Scroll to rewind.

Rewind · Era I

Reed Enterprising

Founder and CTO. My firm, and the datacenter I designed and built.

Rewind. 2026 back to 2021.

Era I · 2021 to now

One event-driven .NET platform on NATS JetStream, built for a regulated payments and telephony business.

I work from first principles. Delete the bloat, keep costs low, FOSS where possible, and pay for a product that just works.

Chapter 01 · The Platform

I architected it, wrote most of it, and operate it in production.

Services
~19
Call records
90M+
Rows migrated live
~1B
~6 hours
156
PRs, one run, each human-reviewed

Chapter 02 · The AI-assisted SDLC

I built the tools the platform is developed with.

Three parallel agents in isolated git worktrees migrated 166 legacy stored procedures to MySQL 8, one human-reviewed PR per object. One run produced 156 PRs in about six hours.

The AI-assisted SDLC

ClaudeAgent.NET is a zero-dependency .NET SDK reverse-engineered from Claude Code's undocumented control protocol. It runs a miniature JSON-RPC MCP server over the control channel itself, with bounded-channel backpressure.

Archon puts one Claude session per chat thread in production. Per-session MCP injection turns in-process C# delegates into first-class tools. Bash runs behind a deny-regex and a per-segment allow-list. When a subprocess dies, Archon resumes the same transcript by session ID and keeps going.

The full story

Oracle gives agents read-only MySQL and observability access over MCP, about 79 tools spanning Loki, Tempo, and Prometheus. PII is denied at the database itself. A curated 2,757-line GRANT script draws a column-level boundary, so the server refuses the read before any row moves. No query phrasing gets past it.

An internal skill marketplace encodes our 5-phase SDLC and wires it into the issue tracker, so the process itself ships and versions like code.

The proof run above ran against Metacorp, the sister company. The rest of that engagement was straight modernization work. I extracted a wire-compatible .NET 10 Native-AOT API from their legacy monolith and moved traffic over piece by piece, on Azure Container Apps behind Cloudflare. I fixed an auth timing attack in its token check. I also built their SFTP-to-Google-Drive skip-trace sync. The vendor deleting your uploaded file is the success signal, so it runs as a per-file state machine with the database authoritative over the filesystem.

Chapter 03 · Observer

NVIDIA's ASR service, deconstructed to a hand-built ONNX CUDA pipeline.

Direct P/Invoke, CUDA graph capture, my own batching and per-GPU dispatch, on GPU hosts I racked myself.

Observer

Dispatch runs one pinned OS thread per GPU because ONNX Runtime keeps graph-capture state in a C++ thread_local. Capture is serialized process-wide. Any allocation mid-capture is fatal, so the memory arena is pre-grown to its measured plateau before capture starts.

Production hit SIGSEGVs in stream capture and I root-caused it to the capture mode. The fix lived in ONNX Runtime's CUDA Plugin EP, which had never shipped. I built it from source, worked out the private CI toolchain that builds it, and patched a missing-header bug in the release tag.

The full story

A LightGBM classifier that scores caller-ID health rides the same pipeline. Trained models are versioned and shipped as OCI artifacts, pulled like any other image.

Chapter 04 · Conclave

One pure function decides call state. Three out-of-order telco feeds, one record.

Writes run a bounded optimistic-CAS loop on NATS JetStream KV. Lose the race, read again and refold.

Conclave

Three telco sources report the same call, out of order and duplicated. Conclave folds them into one call record.

I kept the reducer pure, no I/O and no side effects, so every state transition is testable without a broker or a database running.

The full story

Read the record, fold the event, compare-and-swap. The loop is bounded, so a hot key cannot spin forever.

I wrote one decision function and pointed the live path, retries, the sweep, and the database fallback all at it, so the four paths cannot drift apart.

It replaced the MySQL re-query hot path. Most calls now resolve without touching the database at all.

131 GB 505 tables 1,417 stored procedures 33 schemas

~1,000,000,000

rows, live, no replica

12-phase orchestrator

Chapter 05 · The Migration

131GB, ~1B rows, live, no replica.

The move ran on a 12-phase resumable orchestrator I wrote. Every phase has checkpoint validation and a rollback path. A failed phase resumes where it stopped instead of starting over.

The billion-row migration

Get it wrong and the business stops.

The inventory also carried 139 triggers. Everything staged through an NVMe-RAID0 VM.

The full story

DuckDB over Parquet ran the slow-log forensics. Ten SQL anomaly detectors root-caused a daily query storm and found stored procedures scanning 7.3 billion rows per run.

Also in this era

Contract-first NATS

I brought gRPC's contract discipline to NATS. Drift fails the build. OpenAPIRoslyn analyzerscodegen

Our OpenAPI model contracts double as message contracts. One schema describes both the HTTP surface and what rides NATS. Client code in other languages generates from that same source.

In-house Roslyn analyzers fail the build on contract drift. A service that stops matching its contract does not compile.

An exporter derives OpenAPI 3.1 JSON Schema from the source-generated serializer types. That schema feeds a pipeline that generates a TypeScript SDK covering both HTTP and messaging.

CI runs a schema drift gate, and banned-API analyzers block competing OpenAPI stacks so nobody routes around the contract.

I wanted gRPC’s compile-time agreement without moving the platform onto gRPC. Services in C# and TypeScript now agree at build time, so drift never reaches production.

Cerebro

The identity plane. RS256 JWTs plus Ed25519 NATS credentials, minted live. identityNATS auth-calloutSOC 2

Cerebro is the identity and authorization plane for the whole platform. It mints RS256 JWTs for people and Ed25519-signed NATS credentials for services and devices, through a broker auth-callout.

Per-user subject grants live in the database and take effect immediately, no broker reload. Deny overrides allow. Device-fleet credentials expire in 30 minutes. XKey encrypts the callout payloads.

The SOC 2 controls are enforced in code. An EF Core audit interceptor redacts sensitive fields before they reach a log, so a log line cannot leak what it never sees.

Four client SDKs ship with it: .NET, Blazor WASM, TypeScript, and a shared abstractions library. Wiring auth into a new .NET service is three lines. The browser SDKs refresh themselves before expiry.

RapidContact

Spire's e-signature platform, built to keep taking webhooks with the database down. queue workersESIGN/UETAgraceful degradation

RapidContact is Spire's e-signature and outreach platform, and it started life at VTR. The first build ran signing and correspondence workflows on Azure Durable Functions and Cosmos DB. I rebuilt it as about 14 cooperating queue workers over a staged MySQL queue.

ESIGN/UETA compliance sits in a gate that fails closed. A document that cannot prove compliance does not send.

Documents render at the Cloudflare edge, authenticated back to origin with time-windowed HMAC. Cache keys follow the document, so rotating a link still hits cache.

In FILL mode the service prunes itself to a single webhook-capture endpoint with no database services registered, buffering everything into an Azure Storage Queue. DRAIN replays the backlog through the same code paths live traffic uses, so there is no second implementation to maintain.

Inbound webhooks decouple through a durable JetStream work queue with deterministic message IDs for dedup and a dead-letter queue for messages that refuse to process.

The telephony line

I own the PBX. A database failure never breaks inbound calls. AsteriskLuaAndroid fleetJetStream

I own the production Asterisk/FreePBX itself. Roughly 200 agents make their living on that box, and 90M+ call records sit behind it.

Outbound caller ID comes from a Lua pool selector calling MySQL over ODBC. GetNextCID picks the number live per call through a 7-tier geographic fallback built on a NANPA and Census dataset I assembled myself. Same inputs, same answer, and the first tier that matches wins.

Corsair resolves inbound DIDs to dialplan destinations. When the database is unreachable it falls back to a default route instead of erroring. A collections floor that cannot take calls is a stopped business, so this path fails open.

A native Android dialer (.NET MAUI, Telecom InCallService) runs on a physical 3-carrier device fleet and measures how carriers label our caller ID. Publish-before-ack JetStream with dedup gives exactly-once results and at-most-once billable calls.

Each capture runs under a hard wall-clock budget. One linked cancellation source caps both the capture wait and the ack heartbeat, so a hung PSTN call cannot wedge the consumer.

Rewind · Era II

VTR Technology

Founder and CEO. The stack Spire was rebuilt on started here.

Rewind. 2021 back to 2017.

59 agencies 48 recurring 9 developers 23 repos ~4,800 commits all pre-AI
Era II · VTR Technology

Founded and ran a vertically integrated call-center MSP for five years.

I pulled cable and racked gear myself.

VTR Technology

  • We built call centers from the empty room up: structured cabling, cameras, UniFi networks, workstation fleets, and business fiber. We ran the hosted side too: wholesale carrier voice, PBX, MySQL, web, and email across dozens of agency sites.
  • Wrote the telecom core: Asterisk dialplans with ODBC caller-ID lookup, STIR/SHAKEN attestation, caller-ID reputation.
  • Built CleanCollect, a multi-tenant debt-collections platform (ASP.NET, Azure Functions, skip-trace, automated debtor mail) that agencies ran their entire operations on.
  • Built RapidContact, a multi-tenant e-signature and consumer-correspondence platform, the org’s most collaborative repo. It sent agencies’ templated letters, emails, and texts. Consumers signed payment and settlement documents in it, and every signing was stamped with an IP, geolocation, and timestamp audit trail appended to the signed PDF. ASP.NET MVC, Azure Durable Functions, Cosmos DB, and a .NET SDK an agency’s collection system drives in code. Spire’s RapidContact descends from it.

Rewind · Era III

The origin

Union millwright. Self-taught developer.

Rewind. 2017 back to 2008.

Era III · The Origin

I taught myself C# by reverse engineering.

Local 1163 millwright and carpenter. Power plants, waste treatment, and chip fabs, installing the FOUP-carrying robots at Fab 8. The programming started in my teens, writing for WoWGlider.

The record

  • Reed Enterprising · Founder & CTO

    2021 to present · Remote

    My firm. I contract as hands-on CTO to two sister companies, Spire Recovery Solutions and Metacorp, and I own their estates end to end. In the cloud: a ~19-microservice event-driven platform on a multi-region Azure footprint of ~270 resources, 19 Container Apps, and two ExpressRoute circuits, one privately peered to our telephony carrier. On-prem: a datacenter I designed and built, with Proxmox clusters, ZFS storage in the hundreds of terabytes, a six-GPU inference fleet, an Android device fleet, a 3-node NATS cluster, and self-hosted CI and observability. I wrote most of the code and operate all of it.

  • VTR Technology · Founder & CEO

    2017 to 2022 · New York

    A vertically integrated call-center MSP. 59 customer agencies, 48 on recurring contracts, a 9-developer team I hired and led. 23 repos and ~4,800 commits, all hand-written years before AI coding tools, planned through a 658-item epic-to-story hierarchy. One customer became Spire, where I’m now CTO.

  • Earlier · Union Millwright & Self-Taught Developer

    Before 2017 · New York

    Local 1163. Union trade in power plants, waste treatment, and chip fabs.

Open Source

  • TONL.NET

    A serializer written from nothing, now the wire format Oracle speaks to LLM agents.

    Ref struct readers and writers over Span and IBufferWriter, plus a Roslyn incremental source generator. Zero-allocation, measured faster and lighter than reflection serializers on its benchmark suite.

    360+ spec-compliance tests against the upstream spec. Published on NuGet and running in production.

    iamadamreed/TONL.NET

  • legatus

    A Swift 6 strict-concurrency orchestrator that runs a fleet of coding agents.

    About 10k lines of Swift 6 under strict concurrency. Each agent gets its own git worktree, and task claiming is actor-isolated, stress-tested at 50 concurrent claimers with exactly one winner.

    It steers Claude Code live over its control protocol.

    iamadamreed/legatus

  • TCN.NET

    An SDK built on a vendored 715-file protobuf tree as the contract source of truth.

    Connect-RPC error envelopes parse into typed exceptions. Streaming responses surface as IAsyncEnumerable over hand-rolled NDJSON.

    The vendored contract caught a real enum-drift bug in the vendor API that was silently collapsing every skill to UNSPECIFIED.

  • augment

    A self-hosted LLM routing gateway. A local classifier decides which model gets the request.

    A GPU-hosted, grammar-constrained classifier routes traffic across three providers, using top-2 logprob margin as the escalation signal.

    Provider-continuity locks keep mid-conversation tool results from being orphaned. It runs on a maintained OAuth-forwarding LiteLLM fork.

  • switchboard

    A .NET 10 Kestrel MITM proxy for Claude Code traffic.

    It streams SSE to the client live while recording every exchange to replayable JSON.

    Live stats render in a source-generated reactive TUI.

  • Upstream & SDKs

    Fixes landed in other projects, plus 20+ typed vendor SDKs on NuGet, several Native AOT.

    OAuth header forwarding in LiteLLM, a compatibility fix for a breaking change in Synadia callout.net, and per-worktree account pinning in Orca.

    The SDKs cover payments, telephony, SMS compliance, and HR. Several are Native AOT.

The work lives across two GitHub accounts, github.com/iamadamreed and github.com/srs-adamr.