We build the hard parts

A boutique software engineering studio for AI, cloud, and data systems: the deep-tech work other teams quote, stall on, or walk away from.

Bring us the complex →See the work

AI · cloud · data / shipped, not demoed

↓ scroll

01/ What we do

We build AI systems on cloud & data foundations, drop to systems metal when it matters, and audit what others built.

the deep-tech work other teams quote, stall on, or walk away from

  • agents, retrieval, evals, model routing: systems that earn production, not demos
  • AWS-native, failure-first infra and stores that fit the problem: provable, reproducible, torn down clean
  • microVMs, kernels, FFI: below the runtime when the problem demands it
  • we find where it breaks, where cost hides, where risk lives: prioritized fixes, not a vague report

Selected Work /02

Problem

Agent platforms burn budget on input tokens, and every gateway on the market breaks the provider's prompt cache, ballooning the very cost you're trying to cut.

Outcome

Spend metered, cache intact. Token-efficiency and model routing built in, not bolted on.

TechRustAxumTokiotoken-efficiencymodel routingprompt-cachinghexagonal

Complexity: Provider prompt caches key on a byte-exact, order-sensitive request. Reserialize a field or reorder a header and the cache silently misses, re-billing the entire prompt. We metered, attributed, and routed every call while keeping the upstream payload byte-stable under concurrency, streaming tokens straight through without buffering, so cache hits survive the proxy hop at scale.

Approach: We modeled the cache economics first, then built a byte-stable Rust proxy on a hexagonal core, with cache integrity tracked as an invariant and gated by real end-to-end tests before anything ships.

Problem

Finding one-of-a-kind vintage clothing means endless manual scrolling, and personal style is nearly impossible to express as a search query.

Outcome

A feed that learns what someone wears and acts on it: discovery through checkout, hands-off.

TechReact NativeExpoSupabasepgvectorCLIPembeddingsBedrockCDK

Complexity: Style isn't a query. It's a moving point in a high-dimensional space. We encoded every garment and each shopper's evolving style as CLIP embeddings, ran approximate-nearest-neighbor search over a vintage marketplace that churns constantly, and kept the style vector stable as it learned from each like, handling cold-start and exploration-vs-exploitation so the feed stays fresh without drifting.

Approach: We modeled style as CLIP embeddings over a modular monolith of three bounded contexts, designed across a PM→Architect→Designer→Engineer pipeline with an ADR for every major decision, and validated discovery quality before automating purchase.

Problem

Discretionary trading dies by inconsistency: no transparent rubric, no enforced risk, no proof the edge is real.

Outcome

Disciplined entries with mandatory stops and position caps. An edge you can actually measure.

TechPythonpandasDuckDBtime-seriesAlpacaBedrockevals

Complexity: The hard part is proving an edge is real, not curve-fit. We fused noisy multi-provider market data point-in-time (zero lookahead), scored it deterministically so every run reproduces bit-for-bit, and bounded LLM-derived sentiment as one weighted feature, never the decision, then walk-forward-validated the whole rubric against a benchmark to separate real signal from overfitting.

Approach: We built a deterministic, offline-first scoring core, cross-checked signals across providers, and gated it behind weeks of paper-trading validation against a benchmark before a single live order.

Problem

Health data is scattered across wearables, glucose monitors, and lab panels, and on its own none of it tells a person what to actually do. Generic wellness advice ignores the one thing that matters: their numbers.

Outcome

Specific, personal guidance instead of platitudes: “your HRV is down from 48 to 42ms this week,” with one action targeting the weakest dimension and a nudge to see a doctor when it matters.

TechTypeScriptNode.jsClaude (tool-use)TimescaleDBbiomarker fusionSSECognitoKMSCDK

Complexity: We fuse 130+ markers (HRV, sleep, VO2max, glucose time-in-range, ApoB, hsCRP, HbA1c) from Oura, WHOOP, Dexcom, and lab panels into one composite score, normalizing wildly different cadences (real-time wearables vs. labs that decay on a 90-day half-life). Then, instead of RAG, Claude answers through tool-use, querying each user's own biomarker history live so every reply is grounded in their exact trends, wrapped in emergency pre-checks, forbidden-term post-checks, and an urgency classifier that escalates to a clinician when a marker drifts.

Approach: Per-provider ingestion adapters on a rate-limited polling queue with circuit breakers, a TimescaleDB hypertable for the markers, an adaptive scoring engine, and a streaming Claude tool-use loop. All PHI encrypted app-side (AES-256-GCM) over KMS at rest, every read audited.

Problem

Docker Desktop on macOS is one fat VM with your project bind-mounted across the virtualization boundary: filesystem latency runs multiples of native, cold starts stretch into minutes, and there's no first-class “same stack, branched,” so agents can't work in parallel. Slow tools don't just annoy an agent; they burn its context window on retries and waiting.

Outcome

File sync at 0.3 ms, database branches in 32–35 ms with zero bytes on disk across six live copies, Postgres within 10% of Docker Desktop, cold boot in 2–3 s, and a security review at 0 critical / 0 high. A second VMM backend or a remote node is an extension, not a rewrite.

TechRustVirtualization.frameworkmicroVMsVirtIO-vsockAPFS CoWvmnetTokioclean architecture

Complexity: Replacing Docker means rebuilding the entire stack below it in Rust at the systems level. We drove a VMM through Apple's Virtualization.framework, whose core objects are thread-affine !Send Objective-C with async-completion lifecycles that fight Rust's ownership at every turn; booted a guest Linux kernel small enough to come up in seconds yet able to run Postgres and a V8 JIT; replaced the bind mount with a sub-millisecond host-to-guest file-sync transport over VirtIO-vsock; and added git-like Postgres branching via APFS copy-on-write, quarantining every unsafe FFI call so a thin coordinator can never corrupt a VM it owns.

Approach: We built clean-architecture Rust (an 11-crate workspace, 433 tests, 23 ADRs, zero unsafe in the domain and protocol crates) and twice reversed foundational Day-1 decisions on measured evidence: a low-level VMM to Apple's framework, an MCP server to a CLI-only interface (a 35× token reduction), and a hand-minimized kernel to a trimmed Alpine baseline, every major call put in contact with a real app.

03/ How we work

Tools and tests are table stakes. This is the judgment that keeps a complex system standing.

Design the failure first.

01

We reason about how a system breaks before how it runs, then make whole classes of bug impossible: invalid states unrepresentable in the type system, the dangerous paths locked as enforced invariants, not guidelines.

Evidence over assumption.

02

No claim ships without the command output behind it. We measure against real telemetry and benchmarks instead of rebuilt guesses, and stay skeptical of our own thesis until the data backs it.

Determinism is a feature.

03

We build systems that reproduce bit-for-bit and prove what they did: replayable, auditable, byte-stable, so behavior is verifiable, not "trust us."

Architecture for change.

04

Hexagonal boundaries, DDD bounded contexts, and offline-first cores with swappable adapters, so the system stays testable without the live world and changeable as requirements move.

Done means observed.

05

A feature is finished when it's been booted and exercised in real conditions, the way it will actually be used: passing unit tests is the floor, not the bar.

Scope is a contract.

06

We stay inside the agreed boundary and surface deviations instead of absorbing them silently, and every change traces back to the reason that prompted it.

04/ Our defaults

[01]

Serious, not stiff.

Strong opinions, held quietly and shipped. Easy to work with, hard to bluff.

[02]

Relevance is the job.

The field moves, so we move. Staying current is the work, not a hobby.

[03]

We own the outcome.

If we ship it, we answer for it. We surface the problems early and fix what breaks, no finger pointing.

[04]

Pressure is a privilege.

The hard problems are the point. Bring us the ones that actually matter.

[05]

Credentials are the work.

We learned the field by building and shipping it, not from a syllabus.

[06]

No resume-driven complexity.

We build what the problem needs, not what looks impressive on a slide.

05/ The Process

From first message to hands on keyboard in days, not months. Here's the path.

01

You send the problem.

A short brief: what you're building and where it's stuck.

02

We scope it together.

A focused questionnaire becomes the outcomes, deliverables, and timeline you sign off on: no ambiguity, no scope creep.

03

Intro & kick-off call.

We meet, walk the scope together, and align on outcomes, owners, and timeline, and confirm the fit before either side commits.

04

We lock the start date.

We agree on an onboarding date and exactly what's needed to hit the ground running on day one.

05

You get us set up.

Repo access (GitHub), tracking (Jira / Linear), the docs we need, and a channel (Slack, Teams, or Discord).

06

Hands on keyboard.

We're shipping by the agreed date: visible, traceable work from the first commit.

06/ FAQ

07/ Contact

Bring us the complex.

Tell us what you're building and where it's stuck.

or email [email protected]

BLACK BYTE LABSBuilt in the USA