Logic Gate Labs designs high-performance AI systems from first principles — etched in silicon, proven in production, and tuned for the workloads that other shops won't touch.
Specialist work, not a menu of services. Every engagement is bespoke; the categories below are the lens through which we approach a brief.
Custom systems for problems that don't fit the off-the-shelf prompt-and-pray playbook. Models, data pipelines, evaluation harnesses, the lot — built to outlive the demo.
Throughput, latency, dollars per inference. We profile, port, fuse and quantise until the workload runs the way the silicon was designed to run it.
Embedding ML where it has to live alongside the rest of the business: legacy data, hard SLAs, regulated environments. The work nobody finds glamorous, done well.
Eight systems off the bench. Grounded in what's actually built, honest about maturity, and chosen because the hard part was real. No client logos — the engineering speaks.
Litigation turns on chains — grievance, response, appeal, exhaustion — not text similarity. So we built the graph, not another chunker.
Section 1983 prisoner civil-rights work lives in relationships and timelines. Generic RAG hands a lawyer chunks about a question instead of the actual chain of events — and no lawyer can act on an answer they can't trace to the page.
A monorepo splits pure model-selection, a multi-provider LLM gateway, a partitioned knowledge plane, and the Phoenix host. Documents flow through an LLM intake pipeline into deduplicated graph nodes and edges; a Case Intelligence Layer fuses vector search with one-hop graph expansion into char-budgeted context for a bounded, seven-tool agent.
Three indexes of one corpus — structure, semantics, relationships — fused into a single cited answer, or an honest refusal.
A frontier model reasons brilliantly and remembers nothing about your world. Naive RAG — blind chunking plus top-k cosine — discards document structure, cross-references, and the entities that span a whole corpus, then hands the model disconnected fragments.
Intext co-locates a per-document nested-set tree with leaf HNSW vectors in one table, so a single SQL statement does vector search and small-to-big structural expansion at once. A corpus-wide knowledge graph binds entities by deterministic key; hybrid retrieval fuses vector and lexical search via reciprocal-rank fusion, then grounds through a resolvable citation contract.
File a task; a fleet of agents runs it in isolated VMs — inside your own cloud — and hands back a reviewable pull request.
Background AI engineers execute untrusted, model-driven code changes that have to run somewhere safe, auditable, and cost-visible — ideally inside the customer's own VPC, not a vendor's.
One Elixir umbrella compiles to three release targets — control plane, runner, and in-VM supervisor — selected at boot. Runners dial out over WebSockets and never accept inbound connections, so a runner lives entirely inside a customer's GCP project. Each task provisions a fresh VM whose supervisor dials back over a Channel and streams execution; git credentials never touch argv.
Endpoint protection that keeps its inference on the machine — no cloud call, no telemetry ever leaving the host.
Conventional EDR ships sensitive process, file, and network telemetry to a cloud backend to classify it. Riggs inverts that: every model runs locally, so protection works fully offline and endpoint data never leaves the box.
Platform sensors feed a normalizer that emits OCSF-shaped events into a staged pipeline: threat-intel bloom lookups, a static-AI stage over 256-float Mach-O/ELF feature vectors, a YARA-X and rules stage, and a behavioral stage. A weighted merger combines their scored verdicts under an escalate-never-dilute rule — the ONNX stages sit behind heuristic fallbacks today; the merger, rules, and DLP paths are live and tested.
The model reads every receipt; a confidence gate decides which ones a human ever has to see.
A firm with ~2,000 clients drowns in receipts, invoices, and statements that must become correctly-categorized ledger entries. Naive LLM extraction isn't accurate or auditable enough for a tax-liability context — and a model's self-reported confidence is noise.
A staged Oban pipeline — extract, reconcile, classify, route, notify — runs a cheap model first and escalates behind one provider behaviour. Confidence comes from real signals (beta-smoothed vendor priors, label entropy over logprobs, structural features), never self-report, and routing keys on materiality × ambiguity. Only uncertain items reach a keyboard-first console or a magic-link client portal.
The enterprise planning department — constraint-complete route optimization — inside a live dispatch board a twelve-tech shop can actually afford.
Small trades shops get drag-and-drop calendars, not planning. Real advanced scheduling historically meant a proprietary solver and a $250-an-hour consultant. Open solvers and LLMs finally make it deliverable at SMB prices.
A Python sidecar solves each shop-day as an arc-based VRPTW mixed-integer program in OR-Tools, behind a typed HTTP contract. Hard feasibility is computed app-side and passed as allowed (tech, job) pairs, so the model never sees an illegal assignment. The app re-validates every solution and keeps the MIP plan only if it beats an in-BEAM greedy heuristic — so a dead sidecar can never break the board.
Own your corpus outright — then let one SQL query, not another subscription, curate the stream.
The knowledge you depend on is scattered across feeds, browsers, and Evernote, and rented from services that can vanish. Feeds bury you; clipping the good parts works differently in every browser.
Phoenix LiveView drives the reader, vault, and search while Oban runs fetching, embedding, tagging, and pruning on a schedule. Articles are embedded in-BEAM with Bumblebee into pgvector, and a "For You" stream is ranked entirely in Postgres SQL — cosine distance to learned interest centroids, a disliked penalty, recency decay, and a reserved exploration budget. Claude, budget-gated, types graph edges between near-neighbor notes.
tmux for AI coding agents — many terminals in, one attention signal out.
Run a dozen terminal agents at once and every window is opaque: nothing answers "which one needs me right now?" Permission prompts stall in silence while detached agents keep working.
A background daemon owns every PTY and runs a per-pane vt100 parser for scrollback and screen classification. A per-agent state machine — in an I/O-free core crate — drives Unknown → Working ⇄ Blocked → Done → Idle, and a versioned wire protocol ships length-prefixed frames with server-computed screen diffs coalesced to a ~16 ms tick. Every TUI action is also a CLI verb over the Unix socket.
Practitioners first, technologists second, consultants only by accident. Below: the working brief.
Logic Gate Labs is at the front edge of applied artificial intelligence — not the marketing front edge, the actual one, where models are profiled in nanoseconds and a poorly chosen kernel costs a five-figure cloud bill before lunch.
We build high-performance software that pushes the boundaries of what's possible on the hardware our clients can afford to run. Our team combines low-level systems craft with a working understanding of the businesses we serve. We do not write whitepapers; we ship.
Every brief begins with the same three questions: what is the workload, what is it worth, and what is it allowed to cost? Everything else — the architecture, the framework, the choice of model — falls out of the answers.
We are interested in the boring half of AI: the half that has to keep working at three in the morning when nobody is watching. — House note, 2026
Briefs, problem statements, half-formed hunches. We read everything.
Tell us what's too slow, too expensive, or too strange for the off-the-shelf — and we'll tell you whether it's interesting. Write to info@logicgatelabs.com.