Products
HealthRuntime
Agentic AI – decentralized processing, central consistency.
HealthRuntime, the modular Context-Runtime for AI and Side-by-Side with Enterprise.
HealthRuntime is the modular Context-Runtime for AI in healthcare – Side-by-Side with Enterprise architectures. Via Model Context Protocol (MCP), decentralized AI agents operate directly at the point of care using structured FHIR® data instead of unstructured text. Semantic codes like SNOMED CT, LOINC to arbitrary CodeSystems and context information (Patient, ServiceRequest, ImagingStudy) improve AI results – particularly where AI algorithms can solve diagnostic tasks more effectively.
Via MCP, agents realize bidirectional integration: they access FHIR® resources and can feed results back in structured format (FHIR Observation). 100% FHIR Search enables AI to perform precise and complex queries via tools with deterministic responses that significantly reduce the probability of hallucination while making it verifiable – alongside other strategies. Complex workflows from image analysis to multi-modal correlations and diagnostic decision processes are supported – fully auditable via FHIR Provenance and AuditEvent. Point-of-care processing enables real-time decision support directly at the treatment location – without cloud latency, with complete data sovereignty.
The Foundation – a modular Context-Runtime.
Three core principles: code generation, continuous validation, plugin architecture.
HealthRuntime is a runtime for Digital Health and Health AI, implemented in TypeScript with Deno. The architecture is based on three core principles: code generation from FHIR specifications (StructureDefinitions are automatically transformed into TypeScript validator classes), continuous validation against FHIR specifications, and plugin architecture for loose coupling without direct dependencies.
The plugin architecture enables loose coupling without direct dependencies. Every piece of functionality—from validation to terminologies to AI integration—is implemented as a discrete, composable plugin. This makes HealthRuntime adaptable to different requirements, maintainable through isolated components, testable through independent modules, and performant by consuming only needed functionality. New capabilities are added by creating new plugins, not by modifying existing code. HealthRuntime is fully compliant with the
specification. Deviations can be measured, are treated as bugs, and are fixed immediately.
FHIR Package Registry – Source of Truth for Technical and Non-Technical Decisions.
Technical and non-technical decisions are documented in profiles and Implementation Guides (IG) and stored as FHIR packages in the registry.
HealthRuntime automatically transforms these IG Packages (JSON) into TypeScript validator classes at build time. The operator explicitly chooses the source of truth that the system follows – no automatic updates, but strict adherence to the chosen specification.
This code generation approach provides decisive advantages over runtime validation: Compiled validators are significantly more performant than runtime interpretation, Type Safety through complete TypeScript typing at compile time, and Specification Compliance – generated validators follow identical patterns, always match the chosen source of truth without specification drift, and thereby eliminate inconsistencies from manual implementation.
Image coming soon
Deployment Options – Flexible and Scalable.
HealthRuntime supports deployment in various environments: on-device, at the edge, in clusters, in the cloud, or serverless.
For edge scenarios, HealthRuntime can be deployed as a standalone executable binary – without container infrastructure. For simple deployment scenarios, Docker Compose provides a quick solution – ideal for development, testing, and smaller production environments. For scalable OnPrem installations, HealthRuntime supports Kubernetes with rolling updates, health checks, and automatic scaling.
The plugin architecture enables dedicated HealthRuntime instances, tailored to requirements, physical resources, and data protection – terminology services can, for example, be routed to specialized nodes, while critical patient data can remain on dedicated edge nodes.
One Stack – TypeScript end-to-end, without technology fragmentation.
Unified codebase from backend to frontend.
HealthRuntime is based on a unified technology stack: TypeScript as the consistent language for backend, middleware, and frontend, Deno as a modern TypeScript runtime, PostgreSQL for FHIR resources and terminology. For frontend development, we prefer the modern Deno Fresh Framework for web interfaces and apps, while native frontend development can be implemented by almost anyone today through video coding. For secure access from frontend apps to the HealthRuntime backend FHIR server, HealthRuntime follows the SMART on FHIR specification.
HealthRuntime delivers health expertise, an AI-ready development environment, test kits for development and operations, fully FHIR-compliant and profile-compliant from day one, AI-ready through MCP tools, applications, role and permission management, and much more. The unified codebase eliminates technology fragmentation, significantly accelerates development, and reduces time-to-market significantly compared to custom integrations. AI-supported optimizations enable comprehensive testing of efficiency and security. Developers work with consistent programming paradigms across all layers – from database to user interface.
What HealthRuntime also distinguishes under the hood
fully FHIR®-compliant
Consistent implementation of the specification for maximum interoperability and future security. Deviations are treated as bugs.
FHIR Release 6 ready
Architecture and tooling prepared for current and upcoming FHIR versions.
Edge-optimized & high-performance
Processing directly at the point of care – minimal latency, maximum efficiency.
Modular & flexible
Plugin-based extensibility enables tailored solutions without lock-in.
Auditable plugins for agents & logic
Agents, apps, and business logic integrated in a standardized and traceable way – with direct MCP integration.
MCP for context-driven AI
LLMs and agents access approved, context-related data – secure, auditable, rule-based.
Terminology service
Supports SNOMED CT, LOINC to arbitrary CodeSystems for precise, interoperable data.
Validator service
High-performance validation according to specification incl. profiles and terminologies. Code generation from FHIR packages at build time.
Test-driven development
Standardized test environment with atollee test kits for automated, continuous validation.
Event Sourcing, CQRS & DDD
Clear separation of concerns, robust history, and sustainable extensibility.
Zero-trust architecture
Strict access controls, data minimization, and full auditability.
OAuth 2.0 / SMART on FHIR®
Standards-based authentication and authorization for FHIR resources.
RBAC/ABAC & identity integration
Fine-grained permissions, prepared plugins (e.g., Keycloak, Ory).
Decentralized processing, centralized consistency
Real-time locally, intelligent synchronization to central systems (SSoT).
EHR connectivity
Planned standardized integration into electronic patient records.
Monitoring & developer tools
Live metrics, audit logs, and plug-&-play integration (e.g., Grafana®).
💡 The full FHIR specification brought to an edge-native, modular architecture – standards-compliant, scalable, and flexibly configurable via plugins.
HealthRuntime in action: Deterministic vs. explorative tasks
Deterministic – reliable, structured data and process-oriented workflows with FHIR
Everything that can be clearly defined, standardized, and secured with structured FHIR data. Processes are traceably documented and audit-proof – crucial for privacy, billing, clinical documentation, regulatory communication, and quality assurance.
- Structured medical reports are generated automatically – in a uniform, reusable format.
- Every change is stored – tamper-proof and fully traceable (audit trail).
- Access rights are context-based: only authorized persons see specific information.
- Patient data is clearly linked – even in mobile or distributed use.
- Diagnoses and lab results are coded uniformly (e.g., SNOMED, LOINC) – machine-readable & interoperable.
- Legal requirements (e.g., for DiGA or research) are technically enforced – not just organizationally.
- Digital consents can be granted selectively – e.g., for specific providers or research purposes.
- Registries, studies, or QA receive automatically validated data – standards-based & seamless.
- Second opinions are automatically supported – full records, selectively restricted access.
- Hospitals, practices & systems can be connected in a legally compliant way – without proprietary solutions.
- Medications are documented in structured form – incl. interaction detection.
- Billing data can be exported automatically – for insurers or authorities.
- Interfaces to public reporting systems (e.g., infectious disease control) are standardized.
- Devices deliver automatically readable data – no manual transfer.
- Data from devices or apps is captured and used in a controlled way.
- Protection of sensitive content (e.g., HIV, abortion) is rule-based.
- Version control for all documents – clear history and recoverability.
- Offline use possible – e.g., during outages, disasters, or mobile deployments.
- Decentralized, rule-compliant processing – independent of a central data center.
- Planned: integration with national or private EHRs – structured, secure, standardized.
Explorative – context-aware intelligence & adaptive AI with MCP
This is where AI and agents unfold their potential – based on structured data in the right context. It’s about understanding, suggesting, learning, and supporting – rule-based, transparent, and traceable. The link: the Model Context Protocol (MCP).
- Suggestions for diagnoses or billing codes – context- and patient-specific.
- Individual consent texts are generated appropriately – understandable & legally compliant.
- Medical terminology is explained to patients automatically – clear and trust-building.
- Early detection of risks – e.g., cardiovascular or metabolic.
- Identification of care gaps – e.g., missing follow-ups or duplicate tests.
- Smart appointment suggestions – incl. availability & travel.
- Prioritization of important info – e.g., abnormal findings or critical changes.
- Warnings of possible complications – e.g., delirium, sepsis, overdoses.
- Therapy recommendations based on evidence and individual data.
- Learning from workflows – hints for process improvements.
- Contextual questions (“What’s missing here?”) – clear answers.
- Comparison with similar cases – what worked there?
- Suggestions for suitable studies – incl. inclusion/exclusion criteria.
- More efficient routines – e.g., nursing or ward rounds.
- Assistance with OR/round documentation – saves time & ensures quality.
- Integration of external context data – e.g., weather for asthma/migraines.
- Detection of technical errors or security patterns in logs.
- Why-explanations (explainable AI) for suggestions.
- Improved triage – e.g., ER with context data.
- Offline use – e.g., in disaster response or blackouts.