Adam Reed

Senior Software Engineer · Distributed Systems (.NET)

Self-taught, coding since my teens. Nine years a founder, five of them running VTR, my call-center MSP, as CEO. Hands-on CTO since 2021. I’m closing that chapter on purpose. I want a senior IC seat, new problems, and a strong team. I can lead or carry work alone. What I’m after is collaboration.

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. It runs Spire Recovery Solutions, a collections agency. Metacorp, Spire’s sister company, shares the estate. I contract as their hands-on CTO.

I work from first principles, delete the bloat, keep costs low, and use FOSS where possible.

Chapter 01 · The Platform

I designed it, wrote most of it, and I run 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 of them in about 6 hours.

The AI-assisted SDLC

There was no supported .NET way to drive Claude Code programmatically, so I reverse-engineered its undocumented control protocol into ClaudeAgent.NET, a zero-dependency SDK. It runs a miniature JSON-RPC MCP server over the control channel itself, with bounded-channel backpressure.

Archon is the chat-ops service that puts a Claude agent in every chat thread, one session per 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, our agent data gateway (a house name, not the database vendor), 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, Spire’s 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 skip-trace sync (skip tracing is locating debtors), SFTP to Google Drive. The vendor consumes an uploaded file by deleting it, so deletion is the only success signal. The sync runs as a per-file state machine, with the database authoritative over the filesystem.

Chapter 03 · Observer

NVIDIA’s ASR service, torn down and rebuilt as a hand-built ONNX CUDA pipeline.

We needed call-audio transcription on our own hardware. 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 them 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. Before it, resolving call state leaned on MySQL. The database was the hot path.

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. The live path, retries, the periodic sweep that catches missed events, and the database fallback all call it, so the four paths cannot drift apart.

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

131 GB, ~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.

The billion-row migration

We moved Spire’s production MariaDB to Azure MySQL while the business ran on it. Get a phase wrong with no replica and the business stops.

The inventory also carried 139 triggers. Everything was 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

I wanted gRPC’s compile-time agreement without moving the platform onto gRPC. Our OpenAPI model contracts double as message contracts. One schema describes both the REST 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.

Services in C# and TypeScript now agree at build time, so drift never reaches production. W3C trace context rides NATS headers end to end, so one trace follows a call through every service and JetStream hop.

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. Callout payloads are encrypted with NATS XKey.

The SOC 2 controls are enforced in code. An EF Core audit interceptor redacts sensitive fields before they reach a log line.

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, my previous company, one era down the page. 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. If a document cannot prove compliance, it 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.

It has two outage modes. FILL prunes the service to a single webhook-capture endpoint with no database services registered and buffers 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 repeatedly fail processing.

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. The selector, GetNextCID, picks the number live per call through a 7-tier geographic fallback. I assembled its NANPA and Census dataset myself. The lookup is deterministic. The first tier that matches wins.

Corsair, the inbound-call router, maps each dialed number (DID) to its destination in the dialplan. When the database is unreachable it falls back to a default route. 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. 2022 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.
  • I wrote the telecom core: Asterisk dialplans with ODBC caller-ID lookup, STIR/SHAKEN attestation, caller-ID reputation.
  • We built CleanCollect, a multi-tenant debt-collections platform (ASP.NET, Azure Functions, skip-trace, automated debtor mail) that agencies ran their entire operations on.
  • We 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. 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 that agencies’ collection systems call directly. 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. I started writing C# in my teens, building for WoWGlider, a World of Warcraft bot.

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 multi-region Azure. ~270 resources. 19 Container Apps. Two ExpressRoute circuits, one privately peered to our telephony carrier. On-prem: a datacenter I designed and built. Proxmox clusters and 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. I am the only on-call, and I write the incident reviews.

  • 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. Between VTR and Spire I have reviewed ~95% of the ~760 PRs my developers shipped. 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 zero-allocation serializer with 360+ spec-compliance tests, on NuGet and in production.

    A from-scratch .NET implementation of the TONL data format, a token-optimized alternative to JSON for LLM payloads. Ref struct readers and writers over Span and IBufferWriter, plus a Roslyn incremental source generator. Measured faster and lighter than reflection serializers on its benchmark suite.

    The compliance tests run against the upstream TONL spec. In production it is the wire format Oracle, our agent data gateway, speaks to LLM agents.

    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

    A typed .NET SDK for TCN, a call-center telephony platform. A vendored 715-file protobuf tree is 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 agent-routing 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, an agent-orchestration app.

    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.