// FVLLMP

FVLLMP:
distributed infrastructure, built on Erlang.

The distributed software platform under our federation of lab nodes: where it came from, what it does for PQCF and GenHub2 today, and what is next. It is a separate project from PQCF, with its own responsibilities.

// What FVLLMP is

Where it comes from,
and where it stands.

FVLLMP is Quanterall's four-layer distributed software platform, built on Erlang/OTP and running above the L0 physical infrastructure. It is being advanced as a general distributed infrastructure for connecting computing nodes and coordinating workloads across machines and laboratories.

Where it comes from. FVLLMP was built as the AI infrastructure of TechUPGRADE, our Digital Twin platform: language models running on our own GPUs, the proxy, memory and semantic router in front of them, the development and audit layer, and component-owner agents, with TechUPGRADE itself as the application on top. TechUPGRADE is FVLLMP's first use case; GenHub2, the first application on PQCF, is its newest user, through the federation of its machines.

Status: Used in TechUPGRADE Ten-node validation: planned Open source: planned. FVLLMP is being prepared for validation across an initial ten nodes; after that testing phase, we plan to publish it as open-source software. Neither the ten-node deployment nor the open-source release has happened yet.

// Architecture

Four software layers,
above the physical one.

FVLLMP's own architecture is four software layers on Erlang/OTP, L1 to L4, above the physical infrastructure, L0: the machines at the bottom, the inference and memory services on them, the development teams that use them, the component-owner agents, and on top the application being developed. The first application was TechUPGRADE.

FVLLMP: the physical infrastructure (L0) and four software layers (L1 to L4) L4, the application being developed: the first was TechUPGRADE. L3, the component-owner agents, which know and watch their components and devices, write proposals and talk to each other. L2, the development teams (Hermes plans, Claude Code develops) and the audit system. L1, the semantic router, the vLLM proxy that admits every GPU call, and the memory layer, behind one login. L0, the physical layer: two NVIDIA DGX Spark machines that lend each other model slots. TechUPGRADE uses the platform with its own token and isolated memory. L4 Application what is built the application the system the layers below develop and run the first: TechUPGRADE the Digital Twin platform, its own token and memory L3 Component owner agents an owner per component knows and watches its component and devices proposals writes instructions and proposals, through gates together the owners talk to each other L2 Development teams and audit Hermes plans Claude Code ×N develops audit the development and audit system L1 vLLM proxy, memory, semantic router semantic router checks the token, chooses the route, injects memory and code vLLM proxy admits every GPU call by priority and slots; overflow to the peer memory tasks, facts, history, documents, graph, code: one add and search one login in front of every web interface L0 Physical machines, GPUs, the network NVIDIA DGX Spark · DGX-A the L1 services: proxy, memory, router, the coding and embedding models NVIDIA DGX Spark · DGX-B models only: coding and vision, slots lent to DGX-A lent slots token-authenticated
FVLLMP: the physical infrastructure (L0) and its four software layers (L1 to L4). Solid: implemented; dashed: between the two machines.
  • L0 · Physical. The machines, their GPUs and the network: today two NVIDIA DGX Spark. One runs the whole stack; the other runs models only and lends slots of its coding and vision models. A peer's request is token-authenticated and runs at a lower priority than the machine's own work.
  • L1 · The vLLM proxy, memory and the semantic router. The semantic router, written in Erlang, receives every request: it checks the client's token for the project, chooses the route whose closest example matches the latest human message, and injects only the memory and code that clear a relevance floor; after the final answer it writes the turn back, as a solved task or as facts. The vLLM proxy admits every GPU call, embeddings included, by priority and free slots, with sessions and compaction, and sends overflow to the peer's lent slots. The memory layer gives one add-and-search contract over several stores: how tasks were solved, kept apart per tenant; facts per project; conversation history; documents; entities and relationships in a graph; code search per project. One login stands in front of every web interface.
  • L2 · Development teams and the audit system. Hermes plans; Claude Code, as many instances as needed, develops; beside them, the audit system.
  • L3 · Component-owner agents. An owner agent for every component knows and watches its component and devices, writes instructions and proposals that pass through gates, and talks to the other owners.
  • L4 · The application. The system the layers below develop and run. In the first use case this was TechUPGRADE, our Digital Twin platform, which uses FVLLMP with its own token and isolated memory.

How a request flows: a client sends a request with its token; the router matches its route and injects the memory that clears the floor; the proxy admits it, locally or on the other machine's lent slot (a vision request always runs where the vision model is); after the final answer, the turn is written back to memory, never a reply that only calls tools.

The numbering L0 to L4 is FVLLMP's own. The TechUPGRADE film AI infrastructure, L0–L4 shows these same layers, with TechUPGRADE as the application, L4. PQCF's diagram is drawn without numbers, so as not to be confused with them: its applications run on PQCF, which is designed to run on the execution infrastructure FVLLMP provides.

// What it does for PQCF and GenHub2 today

A federation of lab nodes,
as GenHub2 used it.

GenHub2's first tasks through the federation (17 November) used FVLLMP as follows; each point is documented in GenHub2's federation results.

  • One node per lab, on the lab's own NVIDIA DGX Spark; the nodes are joined by mutual-TLS gates, with no central point.
  • Tasks as GA4GH TES tasks. An application talks only to its own lab's node, with its own token; that node runs each task itself or sends it to a peer that accepts it, under its owner's policy.
  • Data by hash. Every input and output is named by its SHA-256 and checked on the way back.
  • Isolated tasks. A task's container has no network, a read-only file system and fixed limits set by each node's owner.
  • Private task images. Images pass through no public registry: the application hands an image to its own node, the federation carries it to the peers, and each node checks it, its recipe and its purpose against the federation's charter before allowing it.

Measured so far: 11 of GenHub2's tree tasks went from DGX-1 to DGX-2 and came back byte for byte identical. With one task at a time per lab on a peer, they took 36.9 s, against 15.2 s on the lab's own 10 cores: correctness first; capacity comes next.

// FVLLMP, PQCF and GenHub2

Different responsibilities,
one path for a task.

FVLLMP

  • The distributed software infrastructure: nodes, gates between them, task routing between labs
  • Used in TechUPGRADE's AI infrastructure
  • Ten-node validation, then open source: planned

PQCF

  • The scientific-computing framework: photonic simulation, symbolic computation, mathematical physics
  • The task layer through which applications submit work
  • Execution across one owner's Erlang nodes: implemented. Federation-peer execution in PQCF: in development, building on a working prototype exercised through GenHub2

GenHub2

  • The first application on PQCF, and an early test of execution across independent machines
  • The first external application on TechUPGRADE: in its own tenant, it uses TechUPGRADE's simulation engine and 3D visualiser, through the platform's external integration API, for viral genomes, mutation positions and protein structures; this is separate from PQCF and the federation