Private AI Runtime, Context, and Integration Surfaces
FlexInfer runs model lifecycle, OpenAI-compatible proxying, serverless activation, and GPU-aware scheduling inside your own cluster. Loom Core and fi-fhir extend context control and healthcare integration around that runtime boundary.
Start with the product surface when you need lane fit. Use docs and playground when you need implementation detail.
FlexInfer anchors the runtime layer with model lifecycle, serverless activation, routing, and GPU-aware operations, while Loom Core and fi-fhir extend context and integration boundaries around it.
Kubernetes-native model lifecycle, OpenAI-compatible routing, and GPU-aware runtime controls for predictable private or hybrid inference.
Deployment: Model runtime placement, scheduling, caching, and activation stay inside your cluster boundary.
Integration: Applications hit standard inference APIs while runtime operations stay inside your network and observability stack.
Registry-driven MCP config generation, tiered context management, Weaver orchestration, proxy + daemon routing, remote transport, and policy controls for private agent operations.
Deployment: Centralizes MCP server lifecycle and policy boundaries for internal tools and agent access.
Integration: Defines how agents reach internal systems with auditable routing and least-privilege intent.
Healthcare-focused ingestion and transformation workflows (HL7v2 to FHIR) with profile-driven, testable data handling.
Deployment: Data transformation pipeline runs in your controlled environment and deployment topology.
Integration: Profile-driven mapping and validation isolate source variability while preserving operational traceability.
Use these contracts to map deployment and integration boundaries before implementation.
FlexInfer runs inference workloads in-cluster while Loom Core governs MCP routing, 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.
Loom Core provides policy-governed context routing while MentatLab delivers mission-control UX for DAG design and run visibility.
Deployment: UI, gateway, and orchestrator services run in your private Kubernetes footprint.
Integration: Operator workflows connect to internal MCP-governed tools and runtime services without moving control to shared SaaS planes.
fi-fhir handles profile-driven HL7v2/FHIR transformation while FlexInfer provides private runtime execution for downstream model workflows.
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 operator UX for DAG design and run visibility.
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.