FlexInfer is the runtime anchor for private inference, while Loom, MentatLab, and fi-fhir define the context, workflow, and healthcare proof boundaries around it.
The stack is intentionally layered: run and customize models inside your boundary, govern how agents reach tools and context, orchestrate repeatable DAG workflows over direct API models, and use fi-fhir when the workload is sensitive healthcare ETL instead of generic demo data.
Kubernetes-native model lifecycle, OpenAI-compatible routing, GPU-aware runtime controls, quantization, adapters, and artifact delivery for private or hybrid inference.
Deployment: Model runtime placement, scheduling, caching, activation, and adapter workflows stay inside your cluster boundary.
Integration: Applications hit standard inference APIs while runtime operations stay inside your network and observability stack.
Loom plus Loom Core coordinate MCP servers, editor config, agent sessions, tiered context, Weaver routing, sandbox execution, RBAC, audit, HUD, and mobile fleet visibility.
Deployment: Centralizes MCP server lifecycle, daemon routing, context memory, and policy boundaries for internal tools and agent access.
Integration: Defines how agents reach internal systems with bounded context, auditable routing, and least-privilege intent.
Mission Control for DAG-based agent workflows over direct API model calls, internal services, and private inference endpoints such as FlexInfer-hosted models.
Deployment: UI, gateway, and orchestrator services run inside your Kubernetes footprint alongside private model and integration services.
Integration: Workflows call direct model/API nodes and MCP-governed tools without depending on frontier coding harness semantics.
Healthcare-focused ingestion and transformation workflows across HL7v2, FHIR, CSV, EDI X12, and CDA/CCDA with profile-driven, testable data handling.
Deployment: Data transformation pipeline runs in your controlled environment and deployment topology.
Integration: Source Profiles, semantic events, validation, routing, and terminology mapping isolate source variability while preserving operational traceability.
Use these contracts to map deployment and integration boundaries before implementation.
FlexInfer runs private model workloads in-cluster while Loom governs MCP routing, context memory, policy boundaries, and agent/tool access.
Deployment: Model runtime placement, rollout safety, and capacity controls stay inside your cluster boundary.
Integration: Agent access is routed through auditable context policies before reaching internal runtime services and private model endpoints.
Loom provides policy-governed context and tool routing while MentatLab delivers mission-control UX for DAG design, execution planning, and run visibility.
Deployment: UI, gateway, and orchestrator services run in your private Kubernetes footprint.
Integration: Operator workflows connect to direct model/API nodes, internal MCP-governed tools, and runtime services without moving control to shared SaaS planes.
fi-fhir handles profile-driven healthcare transformation while FlexInfer provides private runtime execution for downstream model workflows and AI-assisted integration development.
Deployment: Data transformation and runtime execution remain inside your controlled environment.
Integration: Profile-driven mapping isolates source variability while preserving operational traceability.
Product pages cover lane fit. Docs and playground cover execution. FlexInfer anchors runtime operations, MentatLab adds the orchestration UI surface for DAG run control, and Loom Core continues to govern context and policy boundaries.
Loom Core governs context routing and policy boundaries. MentatLab provides the DAG design and run-visibility layer over direct API model calls, internal services, and private FlexInfer endpoints.
SwiftUI app for fleet monitoring, session management, real-time alerts, and lightweight operator control from iPhone and iPad.
Single-entry MCP and context control plane: registry sync, tiered memory, Weaver orchestration, proxy + daemon routing, and controlled execution.
VS Code extension for multi-platform MCP config sync, skills registry, and agent context workflows.
Zed integration for Loom workflows: consistent servers, shared registry, and repeatable profiles.
Inference control plane for private and hybrid workloads: model lifecycle, serverless activation, routing, and GPU-aware placement.
Healthcare integration tooling: Source Profiles, parsing pipeline, and HL7v2 to FHIR workflows.
FlexInfer already ships runtime control and observability surfaces, while gateway, RBAC, sandbox execution, and HUD visibility work continue around the adjacent Loom Core layer.
Cost monitoring integration: loom/cost-stats RPC, CostMonitor polling, SSE events, and OverviewPanel KPI tile.
RBAC config RPC, denied-calls ring buffer, ServersPanel RBAC sub-tab, and OverviewPanel badge.
Centralized MCP routing via loom proxy with streamable HTTP transport, bearer/OIDC/mTLS auth, and hub failover.
Single context ingress with controlled routing, auditing, and automatic local fallback.
Role-aware permissions for MCP tool access with audit trail, cost tracking, and OAuth 2.1.
Enforces least-privilege context access with auditable decision logs across teams and environments.
mcp-devbox sandbox runtime with Docker and Kubernetes backends for isolated agent execution.
Runs builds, tests, and automation in controlled containers with consistent isolation and audit trails.
OTel tracing across all 59 MCP servers, JSON log correlation, observability stack, and deployment controls.
Full production observability with distributed tracing, structured logging, and repeatable deployment workflows.
Product pages explain lane fit. Docs and playground pages stay aligned on config shape, schema validation, and the operational entrypoints behind each surface.
Start with deployment and integration boundaries, then map the right product lane.
Use docs and playground workflows to validate config, routing, and integration behavior.
Use the consulting path for architecture hardening in private environments.
If you want this stack inside your environment, the fastest path is a scoped audit or build engagement.
Fixed-scope diagnostic for sensitive workloads: architecture review, risk register, deployment constraints, and a 90-day plan.
Build private or hybrid inference infrastructure with observability, GitOps, and safer rollout controls.
Hands-on senior guidance to align teams around an executable platform roadmap.
Implementation notes, architecture decisions, and reusable patterns.