Inference Control Plane
FlexInfer
Private inference operations for teams that need model lifecycle, routing, GPU placement, quantization, adapters, and OpenAI-compatible endpoints inside their own boundary.
Reading the live figure
Products
Products and tools I build
Explore what each product does, how I use it, and the docs, examples, and implementation notes behind it.
Products
Where a product runs behind this site, its row shows a figure read from that system and says whether the number is live or a saved snapshot.
- Loom Suite
Loom
MCP and agent-fleet coordination for private operations: editor sync, single-entry tool access, daemon routing, tiered context, Weaver orchestration, and the Mills delivery pipeline.
Reading the live figure - DAG Orchestration
MentatLab
Mission Control for DAG-based agent workflows that call direct API model nodes, internal services, MCP-governed tools, and private FlexInfer endpoints.
No public telemetry
MentatLab does not publish run data to this site, so no figure is shown.
- Healthcare Integration
fi-fhir
Healthcare ETL and integration tooling for Source Profiles, semantic events, workflow routing, terminology mapping, and HL7v2 parsing and FHIR output.
fi-fhir runs in your browserThe parsing and FHIR mapping kernel compiled to WebAssembly; synthetic samples, and nothing you paste is uploaded.
Local
How I divide the work
Product responsibilities
Product
Best For
Includes
Docs
Playground
FlexInfer
Private inference operations and model customization
Model lifecycle, OpenAI-compatible proxy, GPU-aware placement, quantization, adapters, OCI delivery, and federation
Docs →Open →Loom Suite
MCP, context, and agent-fleet coordination
Loom Core, Loom, editor sync, proxy + daemon runtime, memory, Weaver, HUD, RBAC, and sandboxed execution
Docs →Open →Operating story
From private model to production workflow
Connect private inference to controlled tool access, repeatable workflows, and healthcare integration. Each component has its own deployment requirements and capability limits.
- 01FlexInfer
Operate private model runtimes first
FlexInfer gives teams a Kubernetes-native control plane for model lifecycle, OpenAI-compatible routing, GPU-aware placement, scale-to-zero activation, quantization, adapters, and model artifact delivery.
Can this model run, scale, route, and roll back inside our cluster boundary?
FlexInfer product - 02Loom
Govern the agent and tool boundary
Loom and Loom Core turn MCP sprawl into a single governed entrypoint with registry sync, daemon routing, tiered memory, fleet state, sandbox execution, RBAC, audit, HUD visibility, and Mills autonomous delivery pipelines.
Which agents can reach which tools, with what context, and what audit trail?
Loom Core product - 03MentatLab
Compose repeatable DAG workflows
MentatLab is the mission-control surface for DAG agent orchestration over direct API model nodes and internal services. In this stack, those model calls can target FlexInfer private endpoints instead of a frontier coding harness.
Can operators design, validate, run, and observe the workflow as a graph?
MentatLab product - 04fi-fhir
Apply it to sensitive integration work
fi-fhir provides healthcare ingestion, transformation, and delivery: Source Profiles, HL7v2 parsing and FHIR output, semantic events, workflow routing, terminology mapping, authenticated durable ingress, and AI-assisted explanations inside a controlled environment.
Can legacy clinical data become validated, explainable, routable events?
fi-fhir product
Writing Hub
Read the tradeoffs and postmortems
If you want to see how I think, start with the case studies and writing that explain the decisions behind these products.
Architecture
Architecture snapshots
Diagrams of model hosting, public dashboards, and GPU deployment automation.
Loom Core control plane
Registry-driven client sync, loom proxy ingress, daemon routing, and HUD-backed operator surfaces for private MCP operations.
Loom Core context management
Session-start recall, tiered memory, and prompt-pressure compaction keep agent context bounded and queryable.
Loom Core Weaver orchestration
FlexInfer-backed multi-domain routing with curated tool bundles and compound tools for reusable agent work.
FlexInfer control plane
OpenAI-compatible proxying, model lifecycle control, and GPU-aware execution inside a private cluster boundary.
FlexInfer runtime lifecycle
Artifact preparation, cache gating, quantization, and preload behavior that turns model intent into a ready endpoint.
FlexInfer federation surface
GlobalProxy and FederatedModel coordinate cross-cluster reach while keeping runtime execution local to each cluster.
Healthcare parsing pipeline
Profile-driven transformation flow for sensitive interoperability workloads.
