Products
HealthRuntime™
The Game-Changer: Runtime for AI with the complete DNA of
HealthRuntime™ by atollee is an environment built for speed matching cognitive processes, reliable data structures, flexible extensibility, and security that handles complexity. That's why we at atollee developed a Runtime for AI Agents on FHIR® from the ground up – based on FHIR® R6 requirements.
Implemented with next-generation web technology and consistently edge-native by design – for secure processing and responsive AI at the point of care.
One stack, one team: end-to-end TypeScript – from device to cloud. Test-driven development validates against community specifications with test kits.
Direct data processing without detours: shared FHIR® model and TypeScript type tree (StructureDefinition → TS) – consistent end-to-end.
Modularly extensible and standards-compliant: from prototype to care delivery; 100% FHIR®-compliant and agent-friendly from the start. Community specifications as verified plugins – available as soon as published.
Validation and terminologies where they matter: seamlessly integrated — in backend and frontend — compliant with the FHIR® specification and profiles.
HealthRuntime™ provides support for modern data exchange in Digital Health – based on the FHIR® specification:
Agentic AI – decentralized processing, central consistency.
HealthRuntime™, the modular Context-Runtime for AI in Healthcare – Side-by-Side with Enterprise architectures.
Integrated Model Context Protocol (MCP) connection enables secure, explainable AI agents. Decentralized AI agents operate directly at the point of care using structured health data instead of unstructured text. Semantic codes like SNOMED CT, LOINC and context information significantly improve AI results.
Via standardized tool interfaces, agents realize bidirectional integration: they access structured data and can feed results back in structured format. Deterministic responses significantly reduce the probability of hallucination. Rule-based agent behavior enables transparent decision-making with complete audit trail traceability.
Complex workflows from image analysis to multi-modal correlations and diagnostic decision processes are supported – fully auditable. 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-First architecture.
HealthRuntime™ is a runtime for Digital Health and Health AI, implemented in TypeScript on Deno. The architecture is based on three core principles:
Code generation from FHIR specifications – StructureDefinitions (data structure definitions) are transformed into TypeScript validator classes. This means: Quality assurance based on standards, not manual implementation.
Continuous validation – systems are checked against FHIR specifications. This includes structure validation, terminology binding verification, and constraint checking.
Plugin-First architecture – for loose coupling without direct dependencies. Every piece of functionality is implemented as a discrete, composable plugin. Adaptable to requirements, designed for vibe-coding of custom plugins. Secure service integration without affecting existing functionality.
Every piece of functionality is implemented as a discrete, composable plugin. Systems are composed through configuration rather than code – functionality is added without rebuilding the core. HealthRuntime™ is fully compliant with the specification. Test-driven development validates against community specifications with comprehensive test kits from atollee – thousands of precise scenarios from structural and terminology checks to complex data flows. Every deviation from the FHIR® specification is treated as an error and fixed.
No EHR. No platform.
A runtime for interoperability and AI-powered applications.
FHIR Package Registry – Source-of-Truth for Technical and Non-Technical Decisions.
In profiles and Implementation Guides (IG), technical and non-technical decisions are documented and stored as FHIR packages in the registry.
HealthRuntime™ transforms these IG Packages 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: Compiled validators are significantly more performant than runtime interpretation, Type Safety through complete TypeScript typing at compile time, and Specification Compliance – generated validators always match the chosen Source-of-Truth without specification drift.
Deployment Options – Flexible and Scalable.
HealthRuntime™ supports deployment in various environments: on-device (directly on the device), at the edge (at the point of care), in clusters (multiple servers), in the cloud or serverless (scaling).
For on-device and edge deployments, HealthRuntime™ can be deployed as a standalone executable binary – minimal resource consumption, no additional infrastructure required. Cluster and cloud deployments benefit from container-based solutions with automatic scaling and load balancing. Serverless architectures enable demand-based scaling without permanent infrastructure.
One Stack – TypeScript end-to-end, without technology fragmentation.
Unified codebase from backend to frontend: TypeScript as the consistent language for backend, middleware, and frontend. For frontend development, we prefer the Deno Fresh Framework with Server-Side Rendering (SSR) for modern web interfaces and apps. For secure access from frontend apps to the backend FHIR server, the SMART on FHIR specification is followed.
Provides health expertise, an AI-ready development environment, test kits for development and operations, fully FHIR-compliant and profile-compliant from day one. This eliminates technology fragmentation, accelerates development, and reduces time-to-market significantly compared to custom integrations.
One stack, one team — consistent from device to cloud, backend to frontend. Shared packages, monorepo — types generated from StructureDefinition. Unified linting, testing — one codebase, one workflow.
HealthRuntime™ as Clinical Data Repository (CDR)
| Hybrid DB (Native SQL + Inverted Indexes) | NoSQL-DB only | GraphDB only | |
|---|---|---|---|
| FHIR compliance | 🔥🔥🔥🔥🔥(5/5) | 🔥🔥🔥🔥🔥(2/5) | 🔥🔥🔥🔥🔥(2/5) |
| ACID guarantees | 🔥🔥🔥🔥🔥(5/5) | 🔥🔥🔥🔥🔥(2/5) | 🔥🔥🔥🔥🔥(3/5) |
| Performance (FHIR queries) | 🔥🔥🔥🔥🔥(5/5) | 🔥🔥🔥🔥🔥(2/5) | 🔥🔥🔥🔥🔥(3/5) |
| Performance (Write) | 🔥🔥🔥🔥🔥(5/5) | 🔥🔥🔥🔥🔥(5/5) | 🔥🔥🔥🔥🔥(3/5) |
| References & Hierarchies | 🔥🔥🔥🔥🔥(5/5) | 🔥🔥🔥🔥🔥(2/5) | 🔥🔥🔥🔥🔥(5/5) |
| Reference lookups | 🔥🔥🔥🔥🔥(5/5) | 🔥🔥🔥🔥🔥(2/5) | 🔥🔥🔥🔥🔥(3/5) |
| Full-text search | 🔥🔥🔥🔥🔥(5/5) | 🔥🔥🔥🔥🔥(3/5) | 🔥🔥🔥🔥🔥(2/5) |
| Query flexibility | 🔥🔥🔥🔥🔥(5/5) | 🔥🔥🔥🔥🔥(2/5) | 🔥🔥🔥🔥🔥(3/5) |
| Scalability (overall) | 🔥🔥🔥🔥🔥(5/5) | 🔥🔥🔥🔥🔥(4/5) | 🔥🔥🔥🔥🔥(3/5) |
| Horizontal scaling | 🔥🔥🔥🔥🔥(5/5) | 🔥🔥🔥🔥🔥(5/5) | 🔥🔥🔥🔥🔥(3/5) |
| Maintainability | 🔥🔥🔥🔥🔥(5/5) | 🔥🔥🔥🔥🔥(3/5) | 🔥🔥🔥🔥🔥(3/5) |
| Cost (low) | 🔥🔥🔥🔥🔥(5/5) | 🔥🔥🔥🔥🔥(2/5) | 🔥🔥🔥🔥🔥(2/5) |
Best of both worlds: Transactional consistency + NoSQL performance 🔥🔥🔥🔥🔥(5/5) | Good for simple, large data collections, less suitable for FHIR<sup>®</sup> 🔥🔥🔥🔥🔥(3/5) | Good for graph analytics, less suitable for standard FHIR<sup>®</sup> 🔥🔥🔥🔥🔥(3/5) |
Regarding the database question, we recommend and use a hybrid DB approach combining relational DB & full-text search – from a common Open Source stack with a large community. This approach fits optimally with FHIR®, which is based on proven concepts from modern web technology that HealthRuntime™ can implement directly.
Model Context Protocol (MCP): The Bridge Between FHIR® and Agentic AI.
The Model Context Protocol (MCP) transforms how artificial intelligence interacts with health data by establishing secure, verifiable, and explainable paths between AI agents and clinical information systems.
MCP tool interfaces provide deterministic functions (predictable, verifiable functions) according to roles and rights: structured, auditable calls with defined schemas – embedded in role- and permission-based access control. This enables AI agents precise queries over complex, interconnected data structures.
Rules-compliant access via SMART on FHIR® (OAuth/Scopes), RBAC (Role-Based Access Control) and Policies (policies); technically connected and enforced via the Tool Service. For Trust Communities and B2B transactions, UDAP (FAST Scalable Security) is available as a plugin.
Agents work on released context segments with clear scopes (permission areas) – completely traceable. This creates transparency for teams and patients.
Scaling Health AI – Edge-native, from the beginning
The way software is created is fundamentally changing: More focus on intent specification, orchestration and verification – more efficient and targeted.
At atollee, we translate this change into the healthcare context. Edge-native means: Health-AI runs where it's needed – locally at the point of care.
Our lean, high-performance HealthRuntime™ is specifically designed for efficient edge execution. This creates predictable behavior, auditability and scalability – as system properties that are considered from the beginning. From Proof of Concept to widespread deployment – scalable when use cases prove themselves.
What Distinguishes HealthRuntime™ Under the Hood
Fully FHIR®-compliant
Consistent implementation of the specification for maximum interoperability and future-proofing. Deviations are treated as bugs.
FHIR Release 6 ready
Architecture and tooling are 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 are standardized and traceably integrated – with direct tool connection.
Context for Agentic AI
LLMs and agents access released, context-related data – secure, auditable, and rule-based.
Terminology Service
Supports SNOMED CT, LOINC to any 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 responsibilities, robust history, and sustainable extensibility.
Zero-Trust Architecture
Strict access controls, data minimization, and complete auditability.
OAuth 2.0 / SMART on FHIR®
Standards-compliant authentication and authorization for FHIR resources.
RBAC/ABAC & Identity-Integration
Fine-grained permissions, prepared plugins (e.g., Keycloak, Ory).
Decentralized Processing, Central Consistency
Real-time on-site, intelligent synchronization to central systems (SSoT).
ePA Integration
Prospective standardized integration into electronic patient records.
Monitoring & Developer Tools
Live metrics, audit logs, and plug-and-play integration (e.g., Grafana®).
💡 The complete FHIR specification brought to an edge-native, modular architecture – standards-compliant, scalable, and flexibly configurable via plugins.
