Home 01 Technology 02 Projects 03 Research 04 About 05 GitHub ↗ Contact FuryLogic

Technical focus

The stack, from kernels to interfaces.

FuryLogic works on the layers where intelligent systems are actually constrained: memory bandwidth, scheduling, storage consistency, retrieval quality and the cost of moving data. This page describes what we build and how each layer earns its place.

01 — How the work fits together

Eight disciplines, deliberately connected.

We do not treat these as separate service lines. The inference engine depends on the memory manager, the retrieval system depends on the storage engine, and the research programme feeds the primitives.

FuryLogic engineering domains and representative systems
Domain What we build Representative systems
Inference Engines, schedulers, CUDA kernels, KV cache policy Infernix, OpusEdge, Attention Stream Cache
Memory & compute VRAM pooling, DMA transport, tiering policy VUGVA
Data Storage engines, MVCC, vector indexes, agent memory StrikeDB, Memgent
Retrieval Hybrid search, reranking, crawling, MCP surfaces SearchOS, Imify
Network Adaptive fetch, TLS identity, provider routing Proxify, Chimera Gateway
Systems Kernels, runtimes, language implementations linux.js, Matbox
Automation Document pipelines, OCR, structured tool outputs Lightning OCR
Research Graph-physics reasoning, decision readout SyFox, Synthetic Intelligence

02 — Inference engineering

A token is a memory transaction.

Generating text is rarely limited by arithmetic. It is limited by how fast weights and cache can be read, how many sequences can share one pass, and how much state has to stay resident. We work directly on that budget.

That means writing our own quantized GEMM kernels, batching decode across model families, compressing the KV cache, and reusing prefixes so an agent does not re-prefill a conversation on every turn.

  • Batched decode with a CUDA graph per batch width
  • KV cache eviction, quantization and recurrent checkpoints
  • Expert placement for models larger than VRAM
  • Speculative decoding with MTP and n-gram drafters
INFERENCE PIPELINE FIG. 01 REQ × N continu. batching SCHEDULER KERNELS dp4a · int8 MMA flash attention delta scan quantized GEMM KV CACHE resident blocks int4 · evicted prefix reuse STREAM tokens · tools structured output reuse prefix · avoid re-prefill LATENCY IS MEMORY BANDWIDTH, NOT FLOPS FIG. 01 / FL
Fig. 01 — Inference path Infernix · OpusEdge

03 — High-performance computing

Move the descriptor, not the payload.

Multi-GPU memory is fragmented by default. The usual fix — copying through host memory — throws away a large fraction of throughput. We treat memory as a tiered, virtualized resource and keep the CPU on the control plane.

A promotion across tiers costs 72 bytes of metadata. The data itself moves between devices over DMA descriptors, with prefetch running ahead of the layers that need it.

  • Unified virtual address space across non-NVLink devices
  • 64-byte DMA descriptors and a 1024-slot ring
  • Automatic promotion and demotion across VRAM, DRAM and SSD
  • Measured on hardware from Pascal through Blackwell
MEMORY HIERARCHY FIG. 02 CPU control plane only 64-B DESC moves megabytes VRAM · HOT 1008 GB/s · resident DRAM · WARM 28 GB/s · streamed SSD · COLD 7 GB/s · archival promote demote 72 BYTES OF METADATA PER PROMOTION · CPU TOUCHES NO PAYLOAD FIG. 02 / FL
Fig. 02 — Memory hierarchy VUGVA

04 — Search and retrieval

Retrieval you can evaluate.

A model is only as useful as the context it receives. We build retrieval that combines lexical and dense signals, fuses their rankings, and then reranks the candidates with a model that reads the query and the passage together.

The important part is the loop around it: a judged query set, nDCG and MRR scoring, and the discipline to remove a technique that measures worse — even when it is the more sophisticated one.

  • PostgreSQL full-text search plus pgvector HNSW
  • Reciprocal rank fusion and cross-encoder reranking
  • Query-aware snippets and near-duplicate collapse
  • Abstention when nothing clears the relevance floor
HYBRID RETRIEVAL FIG. 03 QUERY operators filters FULL-TEXT tsvector · BM25 VECTOR pgvector · HNSW RRF rank fusion CROSS-ENCODER threshold · abstain RESULTS scored EVERY CHANGE IS SCORED · nDCG@10 · MRR@10 · RECALL@50 FIG. 03 / FL
Fig. 03 — Hybrid retrieval SearchOS · Imify

05 — Systems programming

The lower layer is the product.

Storage engines, kernels, runtimes and protocol surfaces are where the durable engineering advantages live. We write them in Rust and C, with zero-dependency builds where that removes an entire class of supply-chain risk.

One engine can serve key-value, relational, vector and time-series access over a single consistency model. One userspace binary can be the whole router. One WebAssembly module can run the real Linux kernel.

  • MVCC and write-ahead logging in a single storage substrate
  • RESP compatibility so existing clients work unchanged
  • Execute-in-place kernels for flash-constrained hardware
  • Language runtimes that preserve semantics under load
SYSTEMS STACK FIG. 04 APPLICATION agents · services · SDKs contract PROTOCOL RESP · REST · MCP · SSE · A2A wire ENGINE MVCC · WAL · HNSW · scheduler policy gate · cache · reranker consistency KERNEL / HARDWARE syscalls · DMA · CUDA · SPI-NOR · SIMD budget NO LAYER HIDES THE ONE BELOW IT FIG. 04 / FL
Fig. 04 — Systems stack StrikeDB · linux.js · Matbox

06 — Technical index

What we actually work on.

Each discipline lists the techniques we use and the tooling we reach for. None of it is outsourced to a managed platform.

01

Artificial Intelligence & Machine Learning

We build machine-learning systems where the important questions are operational: what the model costs to run, what happens when it is wrong, and whether the behaviour survives contact with real traffic. That means evaluation harnesses, calibrated refusals and explicit failure modes before benchmarks.

PyTorchONNXGGUFCUDAModel2Vec
02

LLM Inference Engineering

Inference is a systems problem: memory bandwidth, batch scheduling, cache residency and kernel selection. We work at that layer directly — writing kernels, restructuring attention, compressing KV state and making long context fit on hardware people actually own.

RustC++20CUDAAVX-512FlashAttention
03

High-Performance Computing

Performance is usually a data-movement problem. We design around the memory hierarchy — VRAM, DRAM, SSD, L2 — and move payloads with descriptors and prefetch rather than copying them through the CPU. Results are reported per machine, per model, with the baseline named.

RustCUDAPCIeNVMeEigen
04

Distributed Computing

We build systems that stay correct when a node is slow, a peer is dead or a request arrives twice. Consistency models, idempotency, backpressure and circuit breaking are design inputs, not patches applied after the first incident.

RustRESPPostgreSQLRedisgRPC
05

Search & Retrieval Infrastructure

Search is the interface between a model and everything it did not memorise. We build hybrid retrieval — lexical and dense — with real reranking, snippet selection and an evaluation loop honest enough to show when a sophisticated technique is making results worse.

PostgreSQLpgvectorBM25CLIPMCP
06

Systems Programming

The layer below the product is where the durable advantages are. We write storage engines with zero external dependencies, kernel patches that execute in place from flash, router userspaces in a single binary, and language runtimes that hold their semantics under load.

RustCMIPS assemblyLinux kernelWebAssembly
07

Intelligent Automation

Automation is only useful if its authority is legible. Our work separates capability from permission: local-first execution, deny-by-default policy, auditable traces and deterministic tools that do the same thing twice. Model routing and document pipelines sit on top of that base.

MCPTypeScriptPythonDockerOpenAI API
08

Synthetic Intelligence Research

Alongside conventional model work we run a long-horizon research programme into structural reasoning: graph-physics substrates, oscillator dynamics and decision readout without generation. It is early-stage research, and it is documented as such — including what does not work yet.

C++17CDynamical systemsGraph theory

Go deeper

See the systems, not just the domains.

Every discipline above is represented by software you can read, build and run. The projects page carries the details, licenses and measured results.