Skip to content
Catalyze product

Claritus.One: a shared operational AI layer for healthcare organizations

Every healthcare operator we have worked with rebuilds the same foundation before it can automate anything: consolidate the data, agree what the metrics mean, then attach the agents. Claritus.One is that foundation built once as a product — a shared data and semantic layer with operational agents across scheduling, revenue cycle, patient data integrity and staffing.

Platform

Claritus.One

Context

The expensive part of operational AI is not the AI.

The pattern repeats across healthcare organizations. The systems of record are fragmented, the same metric is defined three different ways in three different reports, and so any attempt to automate a workflow starts with six months of data and definition work before a single agent does anything useful. That foundation is substantially the same from one operator to the next, and rebuilding it per engagement is a tax on every project that follows.

Challenge

Point solutions cannot share what they each need most.

The usual response is a set of point tools — one for scheduling, one for the revenue cycle, one for staffing. Each arrives with its own partial copy of the data and its own private definition of the metrics, which means they cannot reason about each other. A scheduling change that creates a staffing problem that creates a revenue problem is one situation, and three disconnected tools will see three unrelated events.

  • Fragmented systems of record, with no shared operational view across them
  • The same metric defined differently in every tool that reports it
  • Point solutions that each rebuild a partial version of the same foundation
  • Automation projects that spend most of their budget before automating anything
  • No path from a workflow that works in one department to the rest of the organization

Approach

Build the layer once, then attach agents to it.

Claritus.One inverts the usual order. Rather than a tool per department, it establishes the shared layer first — one consolidated operational data set with one governed definition per metric — and then treats each operational domain as an agent attached to that layer. Because every agent reasons over the same definitions, they can reason about each other, and a workflow proven in one domain does not have to be rebuilt to reach the next.

System

What the platform provides

A foundation, a set of domain agents on top of it, and a role-appropriate way in.

01

Shared operational data layer

Consolidation across systems of record, with ingestion, validation and freshness tracking handled once rather than per tool.

02

Governed semantic layer

One agreed definition per operational metric, with hierarchy and comparison windows encoded, so every surface above it reports the same number.

03

Domain agents

Operational agents scoped to scheduling, revenue cycle, patient data integrity and staffing — each narrow enough to be accountable and each reasoning over the same shared definitions.

04

Role-based experience

An executive, a department lead and a coordinator need different things from the same system. What each role sees and can ask is scoped to what that role is accountable for.

05

Provenance by default

Every figure and every recommendation carries its source, its freshness and the assumptions behind it. The same discipline applied in our client work, built into the product.

06

Audit and governance

Role-based permissions over queries and actions, with agent activity and assistant conversations retained for review.

Architecture

The system

A single spine that fans out into domain agents and converges on the people accountable for the work.

  1. 01

    Source Systems

    Whatever the organization already runs on. Claritus.One is designed to sit behind these, not replace them.

    • Practice management / EMR
    • Scheduling systems
    • Billing + claims
    • HR + workforce systems
    • Document intake
  2. 02

    Data Platform

    Consolidation, validation and freshness — built once for every agent above it.

    • Automated ingestion
    • Warehouse
    • Validation at boundary
    • Freshness tracking
  3. 03

    Semantic Layer

    The shared vocabulary. This is what allows agents in different domains to reason about the same situation.

    • Governed metric definitions
    • Organizational hierarchy
    • Comparison windows
    • Threshold + target registry
  4. 04

    AI / Model Layer

    Reasoning over governed definitions, with routing by task rather than one model for everything.

    • Text-to-SQL over the semantic layer
    • Narrative synthesis
    • Classification + extraction
    • Anomaly + threshold detection
  5. 05

    Domain Agents

    splits into 4

    The fan-out. Each domain is a scoped agent rather than a separate product with its own private data.

    Scheduling

    Capacity against demand, and the consequences of changing either.

    • Demand patterns
    • Capacity analysis
    • Schedule exceptions

    Revenue Cycle

    The path from visit to payment, and where it breaks.

    • Eligibility + benefits
    • Claim exceptions
    • Documentation completeness

    Patient Data Integrity

    The data quality everything downstream depends on.

    • Duplicate resolution
    • Record reconciliation
    • Intake completeness

    Staffing

    Coverage, compliance and the cost of both.

    • Coverage modeling
    • Credential + training status
    • Utilization
  6. 06

    Orchestration

    Where agent output becomes something that actually happens, with a human in the loop where it should be.

    • Escalation routing
    • Approval gates
    • Action tracking
    • Audit trail
  7. 07

    Roles

    Scoped to accountability rather than to seniority.

    • Executives
    • Department leads
    • Coordinators
    • Compliance

Integration

Built to connect to what a healthcare operation already runs.

Claritus.One is a platform rather than a single engagement, so the integration surface is described by class. What a given deployment connects to depends on that organization's estate.

  • Practice management and clinical systems

    The operational system of record — visits, encounters, scheduling and throughput.

  • Document and intake channels

    Referrals, faxes and inbound clinical documents, classified and routed rather than queued for a person to triage.

  • Revenue cycle systems

    Claims and billing state, so operational and financial views resolve against the same definitions.

  • Cloud data platforms

    The consolidation substrate. The semantic layer is defined once on top of it and every agent reads from it.

  • Write-back to operational workflow

    Agent output lands in the system where the work is assigned, which is what separates this from reporting.

Implementation

How it deploys

Claritus.One is designed to be adopted in the order that builds trust, not the order that demos best.

Technologies

Data

  • Automated ingestion
  • Warehouse
  • Semantic layer
  • Validation

AI layer

  • Text-to-SQL
  • Model routing
  • Classification
  • Narrative synthesis

Workflow

  • Agent orchestration
  • Approval gates
  • Escalation routing
  • Audit trail

Access

  • Role-based permissions
  • Scoped querying
  • Activity logging
  1. 01

    Connect

    Systems of record connected and consolidated, with validation and freshness tracking in place before anything is reported.

  2. 02

    Agree the definitions

    Metric definitions, hierarchy and comparison windows encoded into the semantic layer. Contentious definitions get settled here, in the open.

  3. 03

    Report

    Reporting and natural-language analysis first, because it is the cheapest way to prove the foundation is correct before anything acts on it.

  4. 04

    Attach agents

    Domain agents enabled one at a time, each scoped narrowly and measured on its own workflow rather than on platform-wide claims.

  5. 05

    Extend

    A proven workflow extends to the next domain without rebuilding the layer underneath it — which is the entire reason the layer exists.

Human role

Roles, permissions, and the gates that stay closed.

A shared operational layer across several departments only works if each role sees what it should and no more, and if the actions that carry consequence stop for a person. The platform is built around approval gates rather than around autonomy, because in a healthcare operation the cost of a confidently wrong automated action is not symmetrical with the saving from an automated right one.

  • Role-based experience: executives, department leads and coordinators see the same data resolved to different questions.
  • Approval gates sit in the orchestration layer, not bolted on at the end.
  • Every agent action is attributable and auditable.
  • Clinical decision-making is outside the platform's scope.

Outcome

What the platform changes

Claritus.One removes the foundation work from the front of every operational AI project. An organization spends its effort on the workflows that matter to it rather than on rebuilding a data and semantic layer that looks much the same everywhere.

  • Foundation built once rather than rebuilt per department or per project
  • One agreed definition per metric across every surface that reports it
  • Agents in different domains able to reason about the same situation
  • Shorter path from a proven workflow to the next domain
  • Provenance and audit present from the first deployment rather than added under pressure

Results

Claritus.One is a Catalyze Labs platform. Deployment outcomes depend heavily on an organization's existing systems and data quality, and are covered by client confidentiality. We share specifics directly, under NDA, rather than publishing figures that would not transfer.

What transfers

What this taught us about building the layer once.

The argument for a platform came out of watching the same foundation get rebuilt.

  • Three tools produce three unrelated events

    Point solutions each solve their slice and none can see a pattern that crosses two of them, which is where most operational problems actually live.

  • The foundation is the expensive part, and it is the same every time

    Consolidation, definitions, permissions and provenance get rebuilt per project. Building them once is the entire thesis.

  • Agents are the cheap layer

    Once the foundation exists, adding a capability is small. Organizations that start with the agent find the opposite and conclude AI does not work.

Looking for something closer to your own operation?

All work

Tell us about the workflow. We'll tell you whether we have built something like it.