Pluggable.
Philosophical.
Powerful.

A diagnostic analytics platform
that learns every domain it enters.

Every organisation reconciles.
Almost none of them do it well.

Multiple source systems. Manual spreadsheets. Tribal knowledge.
The person who knows what “normal” looks like retires or changes roles.

Every new domain, every new industry — the same six-month discovery.
The tooling doesn't transfer. The expertise doesn't accumulate.

What if the platform learned
from every domain it entered?

  • An engine that knows how to ingest, validate, diagnose, and present — for any domain.
  • Domain packs that encode what to look for and why — all declarative, all swappable.
  • AI that brings subject matter expertise on demand — new domain, new conversation.
  • A compound effect where each deployment makes the next one faster and richer.

The Platform

Three verbs. Three stores. One continuous cycle.

Make. Desk. Console.

Make
Compile the AFS.
Build the KLS.
Validate everything.
→
Desk
Read the KLS.
Understand patterns.
Write the OPS.
→
Console
AI-assisted refinement.
Author new diagnostics.
Capture knowledge.

The loop closes by authoring — the console drafting a YAML into the AFS, or the Atelier writing one straight from the desk.
Each turn produces a richer, more accurate analytical system.

jin make

The Builder
UI-less processing engine. Pure transformation.

Reads the AFS (YAML definitions, contracts) and the
delivered CSVs; writes the KLS. The security boundary.

Six compilers: signals, theses, verdicts,
Subject Matter, Dossiers, registry.

jin make acme.warehouse_east
Key Properties
No UI. No interactivity. No AI.

Workspace isolation. Never mutates source files.

Deterministic. Same AFS commit + same CSVs → same KLS bytes.

Deployable anywhere. Laptop, CI, cloud function.

Multi-tenant. Each tenant is an isolated DuckDB schema.

jin desk

JinDesk
The SvelteKit app people actually open.

Browse dimensions, taxonomy hierarchies,
signal findings, thesis verdicts,
verdict root causes, expert knowledge.

Human-readable interpretations.
Multi-lingual (EN/DE/FR).
Key Properties
Reads the KLS read-only. No lock contention with make.

Writes the OPS. Notes, bookmarks, bell — operational state stays operational.

Desktop or web. macOS, Linux, Windows, browser.

Authors into the AFS via the Atelier — a signal written here changes what the next make computes.

Locale switching. Same data, different language.

jin console

The AI colleague
A conversational REPL, scoped to one tenant.

Queries what make built.
Walks lineage from finding to source row.
Drafts new YAML straight into the AFS.

“Which entities drive the anomaly?”
“Write a signal for that pattern.”
Key Properties
Scoped to one tenant. Never queries across tenant schemas.

Reads the KLS and the AFS. Writes the AFS.

Lands like a hand-authored one. Built by the next make.

Human confirms. AI proposes, human approves.

Tenant-isolated. AI sees only the assigned tenant.

The console drafts artefacts.
Make builds them. The desk reveals what changed.

console
new signal YAML
→
make
compile + build
→
desk
see new findings
→
console
refine thresholds
→
…

Every turn through the cycle refines understanding.
The system gets smarter because the artifacts get better.

The Architecture

Three stores. Compilers. The analytical pyramid.

Every piece of state has a home

AFS
Artifact Store
Git
All domain content.
CSVs, YAML definitions,
contracts, tenant configs.

Version-controlled.
Separate from engine code.
KLS
Knowledge Store
DuckDB
The analytical database.
Built product of make.

Medallion layers, findings,
verdicts, expert knowledge.
Read-only for desk and console.
OPS
Operational Store
DuckDB
Operational state, per tenant.
Notes, bookmarks, bell
resolutions, scenarios.

Never rebuilt. It outlives
every KLS — restore, don’t regenerate.

Clear ownership. No ambiguity.

AFS
artifacts
→
make
reads AFS
writes KLS
→
KLS
database
→
desk
reads KLS
writes OPS
KLS
database
→
console
reads KLS
writes AFS
→
AFS
artifacts
→
make
rebuilds

AFS is the input to make. KLS is the output.
The console reads the output and writes the input. The loop closes by authoring — no arrow leaves the OPS.

Medallion architecture with a diagnostic layer

Source CSVs
any ERP export
→
Bronze
structural ingestion
→
Silver
validated + typed
→
Gold
consumption contract
→
Diagnostics
signals + verdicts

Bronze = structure. Silver = domain truth. Gold = consumption contract.
No silent filtering — invalid rows are flagged, not dropped, until Gold.

Source-system dispatch happens only in Bronze.
From Silver onward, everything is source-system agnostic.

YAML in. SQL out. Six compilers.

P
Signals
Diagnostic queries on Gold entities. Balance, duplicate, trend, outlier, ratio, temporal, perspective. Produce standardised findings tables.
H
Theses
Business questions evaluated against signal evidence. Weighted evidence chains produce verdicts: confirmed, plausible, not observed.
D
Verdicts
Root cause explanations for confirmed theses. Conditions, confidence scoring, structured recommendations.
S
Subject Matter
Atomic expert knowledge. Free-floating. Optional executable checks. Attributed to a provider with scope and lifecycle.
B
Dossiers
Curated narrative groupings of Subject Matter. The “story” layer. Metadata-only — no SQL, no computation.
R
Registry
Tri-lingual metadata for all instruments. Auto-generated from YAML + glossary. Human-readable display text.

From data signals to root causes

Signals & Perspectives
Technical findings. “Usage exceeds billing by 40%.”
Theses
Business questions. “Revenue leakage from unbilled materials.”
Verdicts
Root causes. “Billing workflow gap in surgical departments.”

Each layer adds interpretation and business context.
Subject Matter floats alongside — expert knowledge anchored anywhere.

Every tenant is an isolated world

  • Schema isolation. Each tenant is a DuckDB schema. Resettable independently. No data leakage.
  • Source-system dispatch. Same domain pack handles multiple ERPs. Column mapping happens once, in Bronze.
  • Platform layer. UNION ALL across tenants for cross-tenant analytics. Opt-in.
  • AI isolation. When AI assists (the console, or Vera at the desk), it sees only its assigned tenant. Never cross-schema.
  • Snapshot. Freeze any tenant's state as an immutable, self-describing DuckDB file. Audit-ready.

Domain Packs

The pluggable expertise layer.

The engine doesn't know what an “invoice” is.
The domain pack does.

Engine (80%)
Medallion pipeline (Bronze → Silver → Gold)
Six YAML → SQL compilers
Findings contract (10 standard columns)
Taxonomy engine (tree + closure table)
JinDesk (discovery, interpretation, i18n)
Multi-tenant platform layer
Orchestration + rebuild scripts

Knows how. Knows nothing about why.
Domain Pack (20%)
Gold contract (entity schemas)
Source-system dispatch (column mappings)
Signal YAML definitions (business rules)
Thesis + Verdict YAMLs
Subject Matter + Dossiers
Registry (tri-lingual display text)
Interpretation rules

Knows why. All declarative. All swappable.

A directory. YAML and JSON. No code.

packs/
domain-name/
→
contracts/
entity schemas
+
signals/
diagnostic rules
+
theses/
business questions
+
glossary/
i18n + registry

Self-contained. Versioned. Declarative.
The engine discovers and loads it via a manifest file.
Swap the directory → swap the domain.

The diagnostic patterns are universal

  • Balance signals — compare two aggregates per entity. Usage vs billing. Received vs sold. Ordered vs delivered.
  • Duplicate detection — same shape everywhere. Duplicate invoices, duplicate shipments, duplicate purchase orders.
  • Trend analysis — rolling average drift. Material costs, lead times, defect rates. The math is identical.
  • Mandatory item — “this entity must have that child.” Safety cert with equipment. Inspection with asset. Signature with contract.
  • Taxonomy hierarchies — cost centres, product categories, regional structures. Same closure table, different labels.

Signal types across domains

Signal Type Healthcare Retail Manufacturing
balanceUsage vs billedReceived vs soldBOM vs actual
mandatory_itemImplant with surgeryCore assortmentQC cert with batch
trendCost drift per monthMargin erosionScrap rate trend
distribution_outlierCase cost outlierReturn rate anomalyYield deviation
duplicateDuplicate billingDuplicate invoiceDuplicate shipment
perspectiveCase integrityStore healthLine efficiency

The compiler generates identical SQL structures.
Only the entity names and thresholds change.

Material/resource flows + financial reconciliation

Healthcare
Cases, procedures, materials, billing
Revenue leakage, compliance gaps, cost outliers
Manufacturing
Work orders, BOMs, inventory, shipments
Phantom consumption, BOM variance, scrap anomalies
Pharma & Life Sciences
Batches, formulations, QC results, distribution
Yield deviation, expiry risk, recall traceability
Retail & Warehouse
Purchase orders, stock movements, sales, returns
Shrinkage detection, dead stock, delivery anomalies
Public Sector Procurement
Tenders, contracts, invoices, deliveries
Duplicate invoicing, contract compliance, budget overruns
Construction
Projects, material requisitions, deliveries, invoices
Material waste, subcontractor billing anomalies

AI as Subject Matter Expert

The framework is the engineering. AI is the domain knowledge.

Three roles, not one

1
Domain Pack Author
AI knows ERP schemas, business logic, regulatory context. It writes the YAML. A human reviews and approves. Weeks, not months.
2
Interactive Analyst
At the console, AI queries the Knowledge Store, interprets findings, and drafts new signals and theses into the AFS. The human stays in the loop.
3
Knowledge Capturer
AI helps encode Subject Matter — turning hallway conversations and expert intuition into structured, attributed, version-controlled artifacts.

New domain = new conversation.
Same framework.

jinflow
engine
+
AI SME
domain knowledge
→
Domain Pack
contracts + signals + i18n
→
Running
Instance

To enter retail: ask AI about inventory schemas, shrinkage patterns,
planogram compliance, margin erosion — generate the domain pack.

To enter pharma: ask AI about batch records, LIMS formats,
yield calculations, GMP compliance — generate the domain pack.

The framework stays. The expertise is injected.

Each domain pack makes the platform
smarter for the next one.

  • Domain 1 reveals that balance signals need interpretation rules — context-dependent severity. The engine gains the interpretation layer.
  • Domain 2 reveals that trend signals need seasonal adjustment. The DSL gains a seasonal modifier. All domains benefit.
  • Each domain's calibrated thresholds inform the next. “What does normal look like?” gets answered by data, not guesswork.
  • AI accumulates cross-domain patterns. The framework gets better at every domain because it's been to others.

The Business

Open engine. Expert domain packs. AI-powered growth.

Three revenue layers

jinflow Engine
Pipeline, compilers, JinDesk shell.
Open or source-available.
Drives adoption and trust.

The platform. Free to evaluate.
Domain Packs
Diagnostic rules, interpretation,
regulatory context, calibrated thresholds.
Subscription per tenant.

The expertise. The revenue.
Custom Domains
Consulting engagement to build
a domain pack for a new industry.
AI-accelerated. Weeks, not months.

The growth engine.

Four layers of defensibility

  • Regulatory knowledge. Every domain has its legal landscape. The domain pack encodes it. Not easily reproduced.
  • Calibrated thresholds. What does “normal” look like? You can't guess this. You earn it from production data.
  • Interpretation rules. The difference between noise and signal. Context-dependent severity that turns raw findings into actionable insight.
  • Source-system expertise. Every ERP has quirks. Column naming conventions, edge cases, undocumented behaviors. Earned through ingestion, not documentation.

What jinflow believes

  • Domain agnosticism. jinflow knows about artifacts, compilers, tenants, and layers — not about invoices, batches, or shipments.
  • Engine / content separation. The engine ships as a versioned package. Domain content lives in a separate git repo — the AFS.
  • DuckDB as the universal contract. Make writes it. The desk reads it. The console queries it. No other shared state.
  • Workspace isolation. Make never mutates source directories. Temp workspace → compile → build → output.
  • Cloud readiness. Same Python library locally and in Lambda. Different callers, same engine.

Boring where it matters. Sharp where it counts.

DuckDB
Knowledge Store
analytical database
dbt
transformation layer
SQL models + tests
Python
engine + CLI
compilers + validators
SvelteKit
JinDesk frontend
desktop + web
Claude
AI backbone
console + authoring

The framework
that learns every domain
it enters.

Highly automated. Deeply interactive.
AI brings the expertise. The engine makes it actionable.
Each deployment makes the next one faster.

Pluggable. Philosophical. Powerful.

jinflow.io